Departamento de Rádio

Engenharia Electrónica e de Telecomunicações

3RA/2022

Tema: Arduino Uno (Microcontrolador Atmega328).

Discentes:

Aider José Dos Santos

Ailton Cumbe

Solange

Virgilio Tembue

Yuran Panguana

Docente: Eng. Celso Guilengue

Maputo, Março de 2022

1
Sumário
1. Introdução............................................................................................................................2
1.1. Historial........................................................................................................................3
2. Arduino................................................................................................................................3
2.1. Evolução dos Arduinos.................................................................................................3
2.2. Arduino Uno Atmega328.............................................................................................5
2.2.1. Alimentação da placa Arduino..................................................................................5
2.2.2. Pinagem do Arduino.................................................................................................6
2.3. Atmega328...................................................................................................................8
3. Programação do Arduino....................................................................................................10
3.1. Funções......................................................................................................................11
4. Experiência: Controlo de vagas de um parqur de estacionamento usando Arduino uno
Atmega328.................................................................................................................................12
4.1. Componentes Usados.................................................................................................13
5. Conclusão...........................................................................................................................14
6 - Apêndice...........................................................................................................................15

1
 1. Introdução
O presente trabalho visa buscar bases e apresentar o resultado da experiência: Simular
um sistema de controle de vagas de um parque de estacionamento usando o Arduino
Uno (Microcontrolador Atmega 328).

O Arduino Uno 328 usa um microprocessador Atmel atmega328.

A plataforma Arduino é uma das mais utilizadas em anos recentes para a simulação e
implementação de projectos electrônicos.

Comportamento ideal, ao aproximar um objecto do sensor 1 o servo motor deve adoptar

a posição aberta simulando a abertura de uma cancela e ao aproxiamar um objecto do
sensor 2 o LCD 16x2 deve mudar de “VAGA 1-DISPONIVEL” para “VAGA 1-
OCUPADA”. Ao afastar o objecto do sensor 1 a vaga volta a posição fechada, ao
afastar o objecto do sensor 2 o LCD deve mudar de “VAGA 1-OCUPADA” para
“VAGA 1- DISPONIVEL”.

2
 1.1. Historial
O Arduino foi criado em 2005 por um grupo de 5 pesquisadores : Massimo Banzi,
David Cuartielles, Tom Igoe, Gianluca Martino e David Mellis. O objetivo era elaborar
um dispositivo que fosse ao mesmo tempo barato, funcional e fácil de programar, sendo
dessa forma acessível a estudantes e projetistas amadores.

2. Arduino
Arduíno é uma plataforma de prototipagem eletrônica de hardware livre e de placa
única, projetada com um microcontrolador Atmel AVR com suporte de entrada/saída
embutido, uma linguagem de programação padrão, a qual tem origem em Wiring, e é
essencialmente C/C++. O objetivo do projeto é criar ferramentas que são acessíveis,
com baixo custo, flexíveis e fáceis de se usar por principiantes e profissionais.
Principalmente para aqueles que não teriam alcance aos controladores mais sofisticados
e ferramentas mais complicadas.

Pode ser usado para o desenvolvimento de objetos interativos independentes, ou ainda

para ser conectado a um computador hospedeiro. Uma típica placa Arduino é composta
por um controlador, algumas linhas de E/S digital e analógica, além de uma interface
serial ou USB, para interligar-se ao hospedeiro, que é usado para programá-la e interagi-
la em tempo real. A placa em si não possui qualquer recurso de rede, porém é comum
combinar um ou mais Arduinos deste modo, usando extensões apropriadas chamadas de
shields. A interface do hospedeiro é simples, podendo ser escrita em várias linguagens.
A mais popular é a Processing, mas outras que podem comunicar-se com a conexão
serial são: Max/MSP, Pure Data, SuperCollider,ActionScript e Java

3
 2.1. Evolução dos Arduinos

Há não muito tempo, para se confeccionar um circuito interativo, era necessário fazer
projetos do zero para uma aplicação específica. Para se fazer pequenas alterações nas
funcionalidades do circuito era necessário um estudo crítico e bastante trabalho. Com o
advento dos microcontroladores, foi possível que problemas que eram tratados com
hardware fossem tratados usando software de computadores. Dessa forma, um mesmo
circuito poderia tomar funções totalmente diferentes, reprogramando e alterando alguns
parâmetros do programa. Mas mesmo assim, trabalhar com microcontroladores não é
tão trivial. Desta forma, em 2005, um grupo de pesquisadores italianos perceberam a
necessidade de criar um dispositivo que possibilitasse a criação de sistemas autônomos
de forma mais simples. O resultado foi o Arduino. A filosofia era criar uma plataforma
que qualquer pessoa pudesse criar um projeto interativo, sem a necessidade de ter que
aprender sobre matérias complexas de engenharia. Dessa forma, qualquer um poderia
ser um criador de tecnologia, não importando idade ou especialidade, apenas algo
presente em sobra no ser humano: a criatividade. O Arduino rapidamente se tornou
popular em todo mundo. Hoje temos várias opções de placas com particularidades
interessantes.

O primeiro Arduino criado foi o Serial Arduino, lançado em 2005, demarcando um

novo momento no universo maker. Seguido da Diecimila (2007), Nano (2008), Uno e
Mega (2010), Mega ADK e Leonardo (2011), Due (2012), 101 (2014) e MKR Wifi e
NB IoT (2018). Na imagem abaixo, podemos conferir a evolução das placas Arduino.

4
 2.2. Arduino Uno Atmega328

Arduino Uno

É a placa mais recomendada para quem está começando na plataforma. Ela possui
excelente custo-benefício, quantidade de porta (entrada/saída) suficiente para a criação
de protótipos com vários sensores e módulos conectados. O microcontrolador da placa
Uno é o ATMega328P, com clock de 16MHz, 14 pinos de I/O, sendo 6 analógicos e 6
com função PWM (Pulse Width Modulation). A placa Uno tem 32KB de memória
flash, onde são armazenados os programas. A conexão com o computador usa um cabo

5
USB A/B, o mesmo utilizado em impressoras USB, podendo ser alimentado com uma
fonte externa chaveada de 7 a 12 VDC.

2.2.1. Alimentação da placa Arduino

A placa pode ser alimentada pela conexão USB ou por uma fonte de alimentação
externa, conforme exibido na figura abaixo:

A alimentação externa é feita através do conector Jack com positivo no centro, onde o
valor de tensão da fonte externa deve estar entre os limites 6V. a 20V., porém se
alimentada com uma tensão abaixo de 7V., a tensão de funcionamento da placa, que no
Arduino Uno é 5V, pode ficar instável e quando alimentada com tensão acima de 12V,
o regulador de tensão da placa pode sobreaquecer e danificar a placa. Dessa forma, é
recomendado para tensões de fonte externa valores de 7V. a 12V.

O circuito regulador para entrada externa é exibido a seguir. Nota-se que o CI

responsável pela regulação de tensão é o NCP1117, da OnSemi. Destaque para o diodo
D1 que protege o circuito caso uma fonte com tensão invertida for ligada.

6
Quando o cabo USB é plugado a um PC por exemplo, a tensão não precisa ser
estabilizada pelo regulador de tensão. Dessa forma a placa é alimentada diretamente
pela USB. O circuito da USB apresenta alguns componentes que protegem a porta USB
do computador em caso de alguma anormalidade.

IOREF – Fornece uma tensão de referência para que shields possam selecionar o tipo de
interface apropriada, dessa forma shields que funcionam com a placas Arduino que são
alimentadas com 3,3V. podem se adaptar para ser utilizados em 5V. e vice-versa.

RESET – pino conectado a pino de RESET do microcontrolador. Pode ser utilizado

para um reset externo da placa Arduino.

3,3 V. – Fornece tensão de 3,3V. para alimentação de shield e módulos externos.

Corrente máxima de 50 mA.

5 V – Fornece tensão de 5 V para alimentação de shields e circuitos externos.

GND – pinos de referência, terra

VIN – pino para alimentar a placa através de shield ou bateria externa. Quando a placa é
alimentada através do conector Jack, a tensão da fonte estará nesse pino.

7
Como interface USB para comunicação com o computador, há na placa um
microprocessador ATMEL ATMEGA16U2

2.2.2. Pinagem do Arduino

Entradas e saídas do Arduino

A placa Arduino UNO possui pinos de entrada e saídas digitais, assim como pinos de
entradas e saídas analógicas, abaixo é exibido a pinagem conhecida como o padrão
Arduino.

Conforme exibido na figura abaixo, a placa Arduino UNO possui 14 pinos para I/o
digitias. Estes Pinos operam em 5 V, onde cada pino pode fornecer ou receber uma
corrente máxima de 40 mA. Cada pino possui resistor de pull-up interno que pode ser
habilitado por software. Alguns desse pinos possuem funções especiais:

PWM : 3,5,6,9,10 e 11 podem ser usados como saídas PWM de 8 bits através da função
analogWrite();

Comunicação serial: 0 e 1 podem ser utilizados para comunicação serial. Deve-se

observar que estes pinos são ligados ao microcontrolador responsável pela comunicação
USB com o PC;

Interrupção externa: 2 e 3 Estes pinos podem ser configurados para gera uma
interrupção externa, através da função attachInterrupt().

8
9
 2.3. Atmega328

O ATmega328 pertence à família AVR da Atmel. Todos os modelos desta família

compartilham uma arquitetura e conjunto de instruções básicas, particularmente os
grupos tinyAVR (microcontroladores ATtiny), megAVR (os ATmega) e XMEGA (os
Atxmega).Os primeiros modelos de Arduino usavam o ATmega8 (com 8K de memória
Flash), que posteriormente foi substituído pelo ATMega168 (com 16K de Flash e
maiores recursos de entrada e saída) e finalmente pelo ATMega328 (com 32K de
Flash). A versão DIP destes três modelos compartilham a mesma pinagem (porém o
ATMega168 e ATMega328 permitem alguns usos diferentes dos pinos). O Arduino
Mega 2560 usa o ATMega2560 com 256K de Flash e uma capacidade muito maior de
entrada e saída. A programação do Atmega328 é feita usando a linguagem C e o
compilador AVR-GCC.

O Atmega328 é constituido essêncialmente por: Uma ULA; Registo de estado; Registos

de uso geral; Apontador de pilha.

A ULA é responsavel por executar todas as operações lógicas e aritmeticas.

O Registo de estado contem informação sobre o resultado da operação executada mais

recentemente.

O apontador de pilha é usado principalmente para armazenar variaveis locais e

armazenar endereços após interrupções e chamadas de subrotinas.

10
Este microprocessador usa uma arquitetura Harvard, usando memórias e barramento
separados para programas e dados. A CPU usa um pipeline (pipelining) de um nível, ou
seja, enquanto está executando uma instrução, a próxima instrução está sendo
pesquisada (pré-extraída) da memória do programa. Graças a esta técnica de pipeline e
barramento separados, o microcontrolador pode executar as instruções em um único
ciclo de clock.

O microprocessador também possui um banco de registros de uso geral de 32 x 8 bits,

com tempos de acesso de um único ciclo de clock. Isso permite que as instruções
aritméticas e lógicas (ALU), possam ser realizadas em um único ciclo de relógio. Na
Figura 5 você pode ver o banco de registros. Existem 6 registros que podem ser
utilizados como 3 registros de endereços indiretos para a memória do programa,
permitindo cálculos eficientes dos endereços na memória do programa, muito utilizados
nos programas C. Estes registos são chamados X, Y, Z e utilizam os registros 26 a 31.

11
Modos de endereçamento do Atmega328

O microprocessador Atmega328 dispõe de 3 modos de endereçamento: *Modo de

endereçamento directo, indirecto e relativo.

O Atmega 328 possui 128 instruções

Interrupções no Atmega328

Interrupções são o mecanismo de hardware pelo qual o microprocessador descobre que

há um evento urgente para participar. Para isso, o microprocessador interrompe a
execução do programa principal para executar um programa com “prioridade”. Por
exemplo, se houve uma mudança de estado em um pino, ou se um byte de dados chegou
na porta serial, ou se um temporizador transbordou, ou se a conversão foi concluída no
ADC, etc., estes são todos os casos típicos ou interrupções comuns que podem ser
ativadas no microprocessador.

As interrupções externas são acionadas pelos pinos INT0 ou INT1 e os pinos do

PCINT. Podemos notar que esses pinos estejam configurados como saída, a interrupção
será desencadeada. Isso é muito útil ao gerar interrupções de software.

3. Programação do Arduino
Ao programar o aarduino usando IDE há normalmente três componentes essenciais:
Bibliotecas externas- que são codigos completamente desenvolvidos e testados que
podem ser usados dentro do nosso codigo; Constantes e variáveis- definem todas as
constantes e variáveis que são usadas para ler e manipular os dados; Funções- fornece
todas as diferentes maneiras de manipular os dados.

12
Todo codigo para o arduino tem duas partes o setup() e o loop(), o setup é executado
apenas uma vez e define as funções dos pinos (se seram de entrada ou saida), é nesta
parte do programa também que se define as variaveis, se importa (inclui) as bibliotecas
externas e se atribui nomes aos pinos. O loop é a outra parte do programa, a parte do
programa que se executa repetidamente, é nesta parte do programa que se encontra a
manipulação dos dados.

Para criar um programa para Arduino podemos usar o IDE, após terminar o sketch no
IDE devemos conectar o Arduino ao computador por meio de um USB e utilizar o IDE
para realizar os testes, depois transferir o sketch para o arduino e depois a placa já pode
operar.

3.1. Funções
As funções do Arduino estão divididas em 3 grupos:

-Funções para controlar a placa do Arduino e realizar computações;

-Funções para o tipo de dados e constantes;

- Funções dos elementos da estrutura do código do Arduino.

Funções para o tipo de dados e constantes:

HIGH|LOW; INPUT|OUTPUT| INPUT_PULLUP; LED_BUILTIN; true|false; Floating

Point Constants; Integer Constants; array; bool; boolean; byte; char; double; float; int;
long;

Short; size_t; string; String(); unsigned char; unsigned int; unsigned long; void; word;
(unsigned int); (unsigned long); byte(); char(); float(); int();long(); word()

Funções para estrutura do codigo:

*loop() *setup() *%(resto) **(multiplicação) *+(adição)

*-(subtração) */(divisão) *=(assigment operator) *&(operador de referência)

*break *continue *do...while *else *for *goto *if

*return
13
*switch...case *while *!=(diferente de) *< (menos que) *<= (less than or equal
to)

*== (equal to) *> (greater than) *>= (greater than or equal to)
*#define(definir)

*#include(incluir) */* */(comentário) *//(comentario de uma linha)

Funções para controlar a placa:

Digital I/O: *digitalRead() *digiralWrite() *pinMode()

Analog I/O: *analogRead() *analogReference *analogWrite

Math: *abs() *constrain() *map() *max() *min() *pow() *sq() *sqrt()

Random numbers: *random() *randomSeed()

Advanced I/O: *noTone() *pulseln() *shiftIn *shiftOut *tone()

Interrupts: *attcchInterrupt() *detachInterrupt *Interrupts()

*noInterrupts()

Time: *delay() *delayMicroseconds() *micros() *millis()

4. Experiência: Controlo de vagas de um parqur de estacionamento

usando Arduino uno Atmega328

14
Para realizar a experiência foram usados 2 sensores ultrassonicos um para detectar a
aproximaçao de um veiculo ao parque de estacionamento e outro para verificar se o
lugar de estacionamento está ou não ocupado. Um servo motor para simular a cancela.

O sensor ultrassonico possui 4 pinos, dois para alimentação(ground e vcc) e dois para
transmitir informação o trigger funciona com saída e o Eco vai funcionar como entrada,
o eco recebe o sinal de retorno e o transmite para a placa de circuito.

15
4.1. Componentes Usados

 1 Modulo i2;
 1 LED;
 1 Resistor;
 1 Motor DC;
 1 Dispositivo Andróid;
 1 LCD 16x2;
 1 Arduino Uno Atemega328;
 Conectores diversos;
 1 Sensores ultra-sónico;
 1 Modulo Bluetooth;
 Uma ponte H;
 1 Carregador de 12v;
 2 placas bredbord.

16
 5. Conclusão
A plataforma Arduino é programada usando uma linguagem de alto nível o C o que
facilita muito a programação quando comparado com algo como um 8085 que usa
assembly sendo mais dificil de programar. Uma das razões para o sucesso do arduino é
a facilidade de programar e o facto de os componentes não terem que ser soldados a
placa, permitindo a reutilização de componentes em um grande numero de projectos
com menor risco de os danificar

17
6 - Apêndice
#include <SoftwareSerial.h>

SoftwareSerial bluetooth(2, 3);

#include <HCSR04.h>

#include <LiquidCrystal_I2C.h>

#include <Wire.h>

int IN1 = 7;

int IN2 = 6;

int PWMR = 9;

char comando;

LiquidCrystal_I2C lcd(0x27, 16, 2);

UltraSonicDistanceSensor sensor_R(4, 5);

int led_R = 3;

void setup() {

//Define os pinos como saida

Serial.begin(9600);

pinMode(IN1, OUTPUT);

18
 pinMode(IN2, OUTPUT);

pinMode(PWMR, OUTPUT);

pinMode(led_R, OUTPUT);

lcd.init();

lcd.setBacklight(HIGH);

lcd.clear();

void loop() {

float cmMsec_R;

cmMsec_R = sensor_R.measureDistanceCm();

Serial.println(cmMsec_R);

if (cmMsec_R < 10.0) {

lcd.setCursor(0, 0);

lcd.print("VAGA 1 - OCUPADA");

digitalWrite(led_R, LOW);

else {

lcd.setCursor(0, 0);

lcd.print("VAGA 1 - LIVRE");

digitalWrite(led_R, HIGH);

19
 }

while (Serial.available()) {

comando = Serial.read();

if (comando == 'F') {

frente();

else if (comando == 'B') {

tras();

else if (comando == 'L') {

esquerda();

else if (comando == 'R') {

direita();

else {

parado();

void tras() {

20
 //Gira o Motor A no sentido horario

analogWrite(PWMR,30);

digitalWrite(IN1, LOW);

digitalWrite(IN2, HIGH);

void frente() {

//Gira o Motor A no sentido anti-horario

analogWrite(PWMR, 30);

digitalWrite(IN1, HIGH);

digitalWrite(IN2, LOW);

void esquerda() {

analogWrite(PWMR, 30);

digitalWrite(IN1, LOW);

digitalWrite(IN2, LOW);

void direita() {

21
 analogWrite(PWMR, 30);

digitalWrite(IN1, LOW);

digitalWrite(IN2, LOW);

void parado() {

digitalWrite(IN1, LOW);

digitalWrite(IN2, LOW);

22