├── README.md
└── src
├── 1-Introducao
└── 1-Boas-vindas.md
├── 2-Ambiente
├── 1-Ambiente-windows.md
├── 2-Ambiente-linux.md
└── 3-Ambiente-online.md
├── 3-Extras
└── 1-Extras.md
├── 4-Modulo-basico
├── 1-Conhecendo.md
├── 10-Buzzer.md
├── 2-Eletronica-basica.md
├── 3-Componentes-eletronicos.md
├── 4-Estrutura.md
├── 5-Acendendo-LED.md
├── 6-IO.md
├── 7-Potenciometro+Push.md
├── 8-Servo-motor.md
└── 9-Temperatura.md
├── 5-Modulo-intermediario
├── Conexao-i2c.md
├── LCD.md
├── Sensor-Ultrassonico.md
└── Teclado-matricial.md
├── Projetos
├── Basico
│ ├── 0-Projeto-blink.md
│ ├── 1-Projeto-semaforo.md
│ ├── 2-Projeto-RGB.md
│ ├── 3-Projeto-Rede.md
│ ├── 4-Projeto-controle-servo.md
│ └── 5-Projeto-termometro.md
└── Intermediario
│ ├── Projeto-calculadora.md
│ ├── Projeto-rede-i2c.md
│ └── Projeto-sensor.md
└── imgs
├── Auxi
├── construction.png
└── ino.png
├── ModuloBasico
├── AcendendoLed
│ └── Circuito.jpg
├── Componentes
│ ├── BotaoArduino.jpg
│ ├── Buzzer.jpg
│ ├── Capacitores.jpg
│ ├── Leds.jpg
│ ├── ProtoboardLimpa.jpg
│ ├── Regulador_5v.jpg
│ ├── Regulador_Arduino.jpg
│ ├── ReleDetalhes.jpg
│ ├── Resistores.jpg
│ ├── Resistores_desafio.jpg
│ └── Sensores.jpg
├── Eletronica-basica
│ ├── AlimentacaoComBateria.jpg
│ ├── LeiDeOhm.jpg
│ ├── Rele.jpg
│ └── Resistores.jpg
├── IO
│ ├── Circuito.jpg
│ ├── IDE.jpg
│ └── Tinkercad.jpg
├── Uno
│ ├── Uno.jpg
│ ├── UnoEsq.jpg
│ ├── UnoInf.jpg
│ └── UnoSup.jpg
└── push-potenciometro
│ ├── Circuito.jpg
│ ├── potenciometro.jpg
│ └── push.jpg
├── Projetos
├── 0-blink
│ ├── IDE_Boards.jpg
│ ├── IDE_Porta.jpg
│ ├── IDE_Selecionando_example.jpg
│ ├── IDE_Upload.jpg
│ ├── IDE_Upload_Done.jpg
│ ├── tinkercad_arduino.jpg
│ ├── tinkercad_arduino_alert.jpg
│ ├── tinkercad_arduino_blink.jpg
│ ├── tinkercad_arduino_cod.jpg
│ ├── tinkercad_arduino_cod_blocks.jpg
│ └── tinkercad_led_aceso.jpg
├── 1-semaforo
│ ├── Semaforo.jpg
│ └── Semaforo_Desafio.jpg
├── 2-RGB
│ └── Esquema.jpg
├── 3-Rede
│ └── Esquema.jpg
└── 4-Servo
│ └── Esquema.jpg
├── TinkerCad
├── Continuar.jpg
├── CriandoCircuito.jpg
├── CriarConta.jpg
├── Final.jpg
├── Inscrever.jpg
└── Opcoes.jpg
├── Unix
└── Site.jpg
└── Win
├── ArduinoIde.jpg
├── DownloadExe.jpg
├── DownloadZip.jpg
└── JustDownload.jpg
/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | 
4 |
5 |
6 |
7 | Arduino4Noobs
8 |
9 | 
10 |
11 |
12 |
13 | Report Bug
14 | ·
15 | Request Feature
16 |
17 |
18 | ## Sobre o Projeto
19 |
20 | O propósito desse repositório, é ensinar o básico de Arduino para iniciantes.
21 |
22 | ## Requisitos
23 |
24 | - É recomendável conhecer lógica de programação;
25 | - O básico de [C](https://github.com/jpaulohe4rt/c4noobs) pode ser de grande ajuda, pois algumas partes podem se tornar um pouco abstratas;
26 | - **Não é necessário ter um Arduino, basta usar o [Ambiente Online](/src/2-Ambiente/3-Ambiente-online.md).**
27 |
28 | # Roadmap
29 |
30 | ## Introdução
31 |
32 | - [Boas Vindas](/src/1-Introducao/1-Boas-vindas.md)
33 |
34 | ## Configuração de Ambiente
35 |
36 | - [Ambiente Windows](/src/2-Ambiente/1-Ambiente-windows.md)
37 | - [Ambiente Linux](/src/2-Ambiente/2-Ambiente-linux.md)
38 | - [Ambiente Online](/src/2-Ambiente/3-Ambiente-online.md)
39 |
40 | ## Recomendações de conteúdos complementares
41 |
42 | - [Conteúdo Complementar](/src/3-Extras/1-Extras.md)
43 |
44 | ## Módulo Básico
45 |
46 | 01. [Conhecendo o Arduino](/src/4-Modulo-basico/1-Conhecendo.md)
47 | 00. [Eletrônica básica](/src/4-Modulo-basico/2-Eletronica-basica.md)
48 | 00. [Componentes eletrônicos](/src/4-Modulo-basico/3-Componentes-eletronicos.md)
49 | 00. [Estrutura de um programa .ino](/src/4-Modulo-basico/4-Estrutura.md)
50 | 00. [Acendendo um LED](/src/4-Modulo-basico/5-Acendendo-LED.md)
51 | 00. [Entrada e Saída (Comunicação serial)](/src/4-Modulo-basico/6-IO.md)
52 | 00. [Potenciômetro + Pushbutton](/src/4-Modulo-basico/7-Potenciometro+Push.md)
53 | 00. [Servo motor](/src/4-Modulo-basico/8-Servo-motor.md)- Ainda em desenvolvimento
54 | 00. [Medindo temperatura](/src/4-Modulo-basico/9-Temperatura.md)- Ainda em desenvolvimento
55 | 00. [Fazendo barulho](/src/4-Modulo-basico/10-buzzer.md)- Ainda em desenvolvimento
56 |
57 | ## Módulo intermediário
58 |
59 | 01. [Sensor ultrassônico](/src/6-Modulo-intermediario/Sensor-Ultrassonico.md)- Ainda em desenvolvimento
60 | 00. [Teclado Matricial](/src/4-Modulo-basico/Teclado-Matricial.md)- Ainda em desenvolvimento
61 | 00. [Conexão I2C](/src/4-Modulo-basico/Conexao-i2c.md)- Ainda em desenvolvimento
62 | 00. [Display LCD](/src/4-Modulo-basico/LCD.md)- Ainda em desenvolvimento
63 |
64 |
65 | ## Projetos
66 | **Básico**
67 |
68 | 00. [Primeiro projeto](/src/Projetos/Basico/0-Projeto-blink.md)
69 | 01. [Projeto semáforo](/src/Projetos/Basico/1-Projeto-semaforo.md)
70 | 00. [Projeto RGB](/src/Projetos/Basico/2-Projeto-RGB.md)
71 | 00. [Projeto rede de Arduinos (Comunicação Serial)](/src/Projetos/Basico/3-Projeto-Rede.md)
72 | 00. [Projeto controle de um servo motor através de um potênciometro](/src/Projetos/Basico/4-Projeto-controle-servo.md)
73 | 00. [Projeto termômetro](/src/Projetos/Basico/5-Projeto-termometro.md)- Ainda em desenvolvimento
74 |
75 | **Intermediário**
76 |
77 | 01. [Projeto sensor de estacionamento](/src/Projetos/Intermediario/Projeto-sensor.md)- Ainda em desenvolvimento
78 | 00. [Projeto rede de Arduinos (Comunicação I2C)](/src/Projetos/Intermediario/Projeto-rede-i2c.md)- Ainda em desenvolvimento
79 | 00. [Projeto calculadora](/src/Projetos/Intermediario/Projeto-calculadora.md)- Ainda em desenvolvimento
80 |
81 | # Autor
82 |
83 | - **Henrique Bento (senhorbento)** - _Graduando em Tecnologia da Informação e comunicação._
84 | [Twitter](https://twitter.com/_MisterBento) - [Linkedin](https://www.linkedin.com/in/henrique-bento-97a4b8231/) - [Dev.to](https://dev.to/_misterbento)
85 |
86 | # Agradecimentos
87 |
88 | - **Kalebe Nascimento (kalNascimento)** - [Github](https://github.com/kalNascimento) - [Twitter](https://twitter.com/kal_Nascimento)
89 |
90 | # Como Contribuir
91 |
92 | Contribuições fazem com que a comunidade open source seja um lugar incrível para aprender, inspirar e criar. Todas contribuições
93 | são **extremamente apreciadas**
94 |
95 | 1. Realize um Fork do projeto
96 | 2. Crie um branch com a nova feature (`git checkout -b feature/featureBraba`)
97 | 3. Realize o Commit (`git commit -m 'Add some featureBraba'`)
98 | 4. Realize o Push no Branch (`git push origin feature/featureBraba`)
99 | 5. Abra um Pull Request
100 |
101 | Made with 💜
102 |
103 |
104 |
105 | 
106 |
107 |
--------------------------------------------------------------------------------
/src/1-Introducao/1-Boas-vindas.md:
--------------------------------------------------------------------------------
1 | # Boas vindas
2 |
3 | Sejam bem vindos ao curso de Arduino para iniciantes. O objetivo principal desse curso é ensinar o básico sobre arduino.
4 |
5 | Arduino é uma plataforma de prototipagem eletrônica open source, 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++. O objetivo do Arduino é criar ferramentas acessíveis, com baixo custo, flexíveis e fácil de se usar por principiantes e profissionais. Principalmente para aqueles que não teriam alcance os controladores mais sofisticados e ferramentas mais complexas.
6 |
--------------------------------------------------------------------------------
/src/2-Ambiente/1-Ambiente-windows.md:
--------------------------------------------------------------------------------
1 | # 2.1 Instalação Windows
2 |
3 | ## Utilizando a Arduino IDE:
4 |
5 | ## Requisitos:
6 |
7 | Caso queira utilizar uma IDE é necessário ter um Arduino e saber qual o modelo do mesmo para baixar o driver correto, neste guia será passado somente a instalação da IDE.
8 |
9 | Existem diferentes maneiras de instalar a IDE do arduino, algumas podem ser encontradas no site oficial do [Arduino](https://www.arduino.cc/en/software) e uma outra será explicada a baixo.
10 |
11 |
12 |
13 | Instalando a IDE no Windows 8.1+
14 |
15 |
16 | Para fazer a instalação no Windows 8.1 ou superior é bastante simples, basta acessar a loja da microsoft, procurar por Arduino IDE e instalar-la. Após finalizado o download a instalação ocorrerá automaticamente.
17 | O ícone do aplicativo deve ser semelhante a este:
18 |
19 |
20 |
21 | 
22 |
23 |
24 |
25 |
26 |
27 | Instalando a IDE no Windows 7+ (Portátil)
28 |
29 | Caso deseje utilizar a versão portátil da IDE, basta acessar o site do [Arduino](https://www.arduino.cc/en/software) e escolher pela opção "Windows ZIP file".
30 |
31 |
32 |
33 | 
34 |
35 |
36 | Após escolher a opção uma nova tela se abrirá basta clica em "Just download" e o download iniciará.
37 |
38 |
39 |
40 | 
41 |
42 |
43 | Após feito o download do .zip basta extrair no local que desejar e executar o arquivo arduino.exe
44 |
45 |
46 |
47 |
48 | Instalando a IDE no Windows 7+ (Instalável)
49 |
50 | Caso deseje utilizar a versão instalável da IDE, basta acessar o site do [Arduino](https://www.arduino.cc/en/software) e escolher pela opção "Windows Win 7 and newer".
51 |
52 |
53 |
54 | 
55 |
56 |
57 | Após escolher a opção uma nova tela se abrirá basta clica em "Just download" e o download iniciará.
58 |
59 |
60 |
61 |
62 |
63 |
64 | Após feito o download do .exe basta executar-lo.
65 |
66 |
67 | A instalação é bem simples, basta clicar em "I agree" -> "Next" -> "Install", durante a instalação podem aparecer telas perguntando sobre a instalação de um dispositivo, basta clicar em "Instalar" em todas as janelas. Após isso basta clicar em "Close" para finalizar a instalação.
68 |
69 |
70 |
71 |
72 | Configurando o VsCode (Opcional)
73 |
74 |
75 | Tambem é possivel utilizar o VsCode, mas o processo é um pouco mais demorado e complexo, por isso estarei deixando esse [video](https://www.youtube.com/watch?v=08N86hk8ZaY), com uma explicação bem completa do passo a passo.
76 |
77 |
78 | Uma vez configurado o ambiente, hora de testa-lo, você pode seguir para o [primeiro projeto](/src/Projetos/0-Projeto-blink.md) antes de ir para o módulo básico =)
--------------------------------------------------------------------------------
/src/2-Ambiente/2-Ambiente-linux.md:
--------------------------------------------------------------------------------
1 | # 2.2 Instalação Linux
2 |
3 | ### Requisitos:
4 |
5 | Caso queira utilizar uma IDE é necessário ter um Arduino e saber qual o modelo do mesmo para baixar o driver correto, neste guia será passado somente a instalação da IDE.
6 |
7 | Existem diferentes maneiras de instalar a IDE do arduino, algumas podem ser encontradas no site oficial do [Arduino](https://www.arduino.cc/en/software) e uma outra será explicada a baixo.
8 |
9 |
10 | Baixando a IDE pelo terminal.
11 |
12 | Abra um terminal, e confirme se o seu sistema é 32 ou 64 bits, use o seguinte comando no terminal:
13 |
14 | ```
15 | uname -m
16 | ```
17 | Após feito a verificação você pode utilizar o site oficial do [Arduino](https://www.arduino.cc/en/software) para baixar o que se enquadra melhor com seu sistema, são essas opções como na imagem a baixo.
18 |
19 |
20 | 
21 |
22 |
23 | Localize o arquivo e o extraia utilizando o comando a seguir:
24 |
25 | ```
26 | tar xf arduino-version.tar.xz
27 | ```
28 |
29 | Acesse a pasta onde foi extraido o arquivo como por exemplo:
30 |
31 | ```
32 | cd arduino-version
33 | ```
34 | Utilize o seguinte comando para iniciar a instalação:
35 | ```
36 | ./install.sh
37 | ```
38 | Basta seguir as instruções dadas através do terminal e sua IDE estará pronta para ser utilizada.
39 |
40 |
41 |
42 |
43 | Configurando o VsCode (Opcional)
44 |
45 |
46 | Tambem é possivel utilizar o VsCode, mas o processo é um pouco mais demorado e complexo, por isso estarei deixando esse [video](https://www.youtube.com/watch?v=08N86hk8ZaY), com uma explicação bem completa do passo a passo.
47 |
48 |
49 | Uma vez configurado o ambiente, hora de testa-lo, você pode seguir para o [primeiro projeto](/src/Projetos/0-Projeto-blink.md) antes de ir para o módulo básico =)
--------------------------------------------------------------------------------
/src/2-Ambiente/3-Ambiente-online.md:
--------------------------------------------------------------------------------
1 | # 2.3 Ambiente Online
2 |
3 |
4 | Uma opção rápida e simples para você utilizar o Arduino sem precisa adquiri-lo são os simuladores.
5 |
6 |
7 | A minha recomendação é o site [Tinkercad](https://www.tinkercad.com/), você pode testar código, novos circuitos (sem o risco de queimar os componentes) e pode fazer os projetos propostos pelo curso de forma gratuita e simples.
8 |
9 |
10 | O Tinkercad também pode ser utilizado para deixar seu projeto documentado, caso queira utilizá-lo novamente.
11 |
12 |
13 |
14 | Criando uma nova conta
15 |
16 | Infelizmente é necessário criar uma conta para utilizar o site, para isso basta clicar no botão "Inscreva-se agora" no canto superior direito.
17 |
18 |
19 | 
20 |
21 | Após isso aparecerá uma janela com algumas opções no centro da tela, clique em "Criar uma conta pessoal"
22 |
23 |
24 | 
25 |
26 | Após isso aparecerá uma janela com mais opções no centro da tela, no caso farei utilizando uma conta google, utilize a sua conta que seja mais conveniente.
27 | **Obs.: Ao clicar em "Mais opções de login..." aparecerá a opção de login com o Facebook e com o Microsoft, por padrão só é mostrado Google e Apple.**
28 |
29 |
30 | 
31 |
32 | Após feito o login, uma janela será aberta com a opção de Continuar, basta clicar nela e o processo será concluído.
33 |
34 |
35 |
36 | 
37 |
38 | Uma vez terminado o processo uma ultima janela se abrirá basta clicar no botão de fechar.
39 |
40 |
41 | 
42 |
43 |
44 | Para criar um projeto utilizando o arduino basta clicar na aba "Circuitos" (1) no canto esquerdo e em seguida "Criar novo Circuito"(2)
45 |
46 |
47 | 
48 |
49 |
50 |
51 | Uma vez criada a conta, hora de testar o ambiente, você pode seguir para o [primeiro projeto](/src/Projetos/0-Projeto-blink.md) antes de ir para o módulo básico =)
52 |
--------------------------------------------------------------------------------
/src/3-Extras/1-Extras.md:
--------------------------------------------------------------------------------
1 | # 3.1 Recomendações de conteúdos complementares
2 |
3 | Existem alguns excelentes canais no youtube para quem está começando e até mesmo já trabalha com Arduino. Irei disponibilizar os que conheço a baixo, durante as aulas irei citar alguns vídeo específicos como conteúdo complementar.
4 |
5 | 01. [Brincando com Ideias](https://www.youtube.com/c/BrincandocomIdeias)
6 | Canal focado especialmente em IOT.
7 |
8 | 00. [WR Kits](https://www.youtube.com/c/canalwrkits)
9 | Eletrônica do básico ao avançado.
10 |
11 | 00. [GV ensino](https://www.youtube.com/c/GVensino)
12 | Eletrônica, programação e matemática.
13 |
14 | 00. [CFB cursos](https://www.youtube.com/c/cfbcursos)
15 | Cursos de programação e tecnologias de desenvolvimento.
16 |
17 | 00. [Mundo da elétrica](https://www.youtube.com/channel/UCQzm6RcaOty8QU2VhHbRg-g)
18 | Eletricidade, aulas e práticas.
19 |
20 | 00. [Eletrônica Fácil](https://www.youtube.com/channel/UC6yeSnpMzKXHbxuEVmcvmhw)
21 | Eletrônica de maneira fácil e prática.
22 |
23 | 00. [Manual do Mundo](https://www.youtube.com/watch?v=sv9dDtYnE1g&list=PLScovg-nsTLpTf4zJ56XYBOvAAbLVE6Ua)
24 | Embora o canal não seja focado em Arduino, existe uma playlist que pode ser bastante útil, ao clicar no link você será redirecionado para ela.
25 |
26 | 00. [Laboratório da Julia](https://www.youtube.com/c/Laborat%C3%B3riodaJulia)
27 | O Canal não é focado em Arduino, mas possui vários vídeos que são bastante interessantes relacionados a eletrônica de um modo geral.
28 |
--------------------------------------------------------------------------------
/src/4-Modulo-basico/1-Conhecendo.md:
--------------------------------------------------------------------------------
1 | # 4.1 Conhecendo o Arduino
2 |
3 | # Sumário
4 |
5 | 01. [Tipos](#Tipos-de-Arduino)
6 | 1. [Arduino UNO](#Arduino-UNO)
7 | 00. [Pinos](#Pinos)
8 | 1. [Pinos digitais](#Pinos-digitais-Parte-Superior)
9 | 2. [Pinos Analógicos](#pinos-de-energia-e-analógicos-parte-inferior)
10 | 00. [Alimentação](#botão-reset-usb-e-fonte-de-energia-lado-esquerdo)
11 | 00. [Considerações finais](#considerações-finais)
12 |
13 | # Tipos de Arduino
14 |
15 | ## Arduino UNO
16 |
17 | Atualmente no mercado existe uma grande quantidade de tipos de Arduino, dentre eles temos como exemplo, Mega, Nano, Lilypad e o mais utilizado é o Arduino UNO. Durante o curso iremos utilizar somente o modelo UNO. Porém ao fim dessa explicação irei mostrar algum outros modelos.
18 |
19 | 
20 |
21 |
22 | Na parte superior e inferior da imagem é possível notar que existe alguns "furos"/"quadrados" com algumas descrições, esses "furos" são comumente chamados de pinos, e será como irei mencioná-los.
23 |
24 |
25 | # Pinos
26 |
27 | ## Pinos digitais (Parte superior)
28 |
29 |
30 | 
31 |
32 |
33 | Os pinos que vão de 0 a 13 são pinos programáveis, através de comandos, que veremos mais a frente, é possível executar uma infinidade de funções com eles, com uma infinidade de compontes, seja acender um LED, controlar um servomecanismo, ler dados de sensores e até mesmo controlar as luzes de sua residência. Todos os pinos possuem pelo menos o estado de 1 ou HIGH para ligado e 0 ou LOW para desligado.
34 |
35 | Ainda nesses pinos de 0 a 13 é possível notar alguns outros pontos, como no pino 0 que recebe a sigla RX e o pino 1 que recebe a sigla TX. A sigla (TX) significa que este é um pino que pode ser utilizado para transmissão e a (RX) significa que este é um pino que pode ser utilizado para recepção de dados. Mais a frente na [aula 6](/src/4-Modulo-basico/6-IO), iremos falar mais aprofudandamente sobre eles, o importante no momento é saber que eles servem para comunicação.
36 |
37 |
38 | É possível notar que existem pinos com o simbolo til (~), que no caso são os pinos 11, 10, 9, 6, 5 e 3. Esses pinos são os chamados pinos de PWM, nesses pinos é possível controlar não somente o estado de ligado ou desligado, como também estados intermediários, um bom exemplo é o controle de intensidade de um LED, ele pode ficar mais ou menos "brilhante" de acordo com a programação. Deixarei um video do canal WR Kits caso tenha interesse em se aprofundar sobre pinos pwm nesse [link](https://www.youtube.com/watch?v=AtnrtZAqgCM)
39 |
40 |
41 | Ainda na parte superior da nossa placa, é possível notar os pinos AREF e GND, o pino GND serve como nosso pino (-) negativo, um exemplo de onde vemos isso é em pilhas, onde o lado chato é o negativo e o pontudo o positivo. O pino de GND serve para fechar o contato com o polo positivo, que pode estar ligado em qualquer um dos 13 pinos, desta forma fazendo com que a corrente flua através dos componentes.
42 |
43 | De maneira análoga, imagine que você tem um autorama, se o circuito por onde os carrinhos passam não estiver fechado, em algum momento eles vão cair do circuito. Da mesma maneira ocorre com a energia, se não tivermos um circuito fechado, a energia escapa e não passa pelo componente.
44 |
45 |
46 | Já o pino AREF é utilizado quando queremos limitar a tensão dos pinos analógicos, por padrão esse valor é de 5V, podemos limitar apenas para valores menores.
47 |
48 | ## Pinos de energia e analógicos (Parte inferior)
49 |
50 | Já na parte inferior é possível notar 2 conjuntos de pinos, os pinos de power (energia) e os pinos analog in (entradas analógicas) vamos falar primeiro dos pinos power ou pinos de energia.
51 |
52 |
53 |
54 | 
55 |
56 |
57 | O pino IOREF diferente do AREF, tem a funcionalidade de dizer qual a tensão que está saindo por padrão do Arduino, que no caso é 5V.
58 |
59 |
60 | O pino reset tem a mesma funcionalidade do botão de reset, basicamente reiniciar o Arduino.
61 |
62 |
63 | Os pinos 3.3V e 5V são pinos de saída de energia, que tem como objetivo alimentar nossos componentes, sejam eles LEDs, relés ou até mesmo sensores de presença. Como cada componente tem uma tensão diferente, existem esses 2 pinos para que possamos ter maior suporte a diferentes componentes.
64 |
65 |
66 | Os pinos GND são internamente conectados com o GND da parte de cima, e tem a mesma funcionalidade.
67 |
68 |
69 | O pino Vin tem como finalidade ser mais uma forma de entrada de energia para o Arduino, ele é internamente conectado com a porta de alimentação que se encontra no canto esquerdo, veremos um exemplo dessa ligação na [aula 2](/src/4-Modulo-basico/2-Eletronica-basica).
70 |
71 |
72 | Os pinos de A0 à A5 são os pinos analógicos, normalmente são utilizados como entrada de dados para componentes, como por exemplo um potenciômetro.
73 |
74 |
75 | Existem ainda alguns componentes que estão mais ao centro da placa, que são cristal oscilador, capacitores, reguladores de tensão e o chip ATMega328, o funcionamento de alguns desses componentes serão explicados de forma mais detalhada na [aula 3](/src/4-Modulo-basico/3-Componentes-eletronicos).
76 |
77 |
78 | Existem ainda uma infinidade de outros modelos de Arduino, caso queira conhece-los recomendo esse [artigo](https://www.arduino.cc/en/hardware). A baixo temos uma imagem com alguns deles.
79 |
80 |
81 |
82 | 
83 |
84 |
85 | Imagem retirada do site: http://ardufc.blogspot.com/2012/10/modelos-do-arduino.html
86 |
87 | ## Botão reset, USB e fonte de energia (Lado esquerdo)
88 |
89 | Na parte esquerda da nossa imagem podem notar 3 grandes componentes, o botão reset (1), USB tipo B (2) e a entrada para fonte de energia (3), vamos falar melhor deles a baixo.
90 |
91 |
92 |
93 | 
94 |
95 |
96 | (1) Este botão é o botão chamado de reset, ele serve basicamente para reiniciar o arduino, assim como o botão reset de um computador.
97 |
98 |
99 | (2) Esta é a porta de comunicação do arduino, na grande maioria dos modelos de Arduino UNO disponíveis no mercado, essa entrada é USB do tipo B, o mesmo cabo é usado frequentemente em impressoras. É possível utilizá-la para conectar-se à um computador, por exemplo. Por ela é possivel passar o programa para a placa e também é possível ler os dados gerados no Arduino, essa porta é internamente conectada com os pinos 0 e 1, que são os pinos de comunicação.
100 |
101 |
102 | (3) Esta é a porta de entrada de energia, caso você queria utilizar seu Arduino sem um computador é possível liga-lo utilizando essa porta. Lembrando que a fonte deve ter de 9 à 12V e pelo menos 1A. Falaremos melhor dessas especificações na [aula 2](/src/4-Modulo-basico/2-Eletronica-basica).
103 |
104 |
105 | ## Considerações finais
106 |
107 | Para finalizar essa aula, um video complementar (não obrigatório) sobre os tipos de arduino do canal Brincando com ideias, segue o [link](https://www.youtube.com/watch?v=FbYd9KPkkl4).
108 |
--------------------------------------------------------------------------------
/src/4-Modulo-basico/10-Buzzer.md:
--------------------------------------------------------------------------------
1 | # 4.10 Buzzer
2 |
3 | # Sumário
4 |
5 | 01. [Introdução](#introdução)
6 | 00. [Buzzer](#buzzer)
7 | 00. [Circuito](#circuito)
8 | 00. [Código](#código)
9 | 00. [Considerações finais](#considerações-finais)
10 |
11 | # Introdução
12 |
13 | # Buzzer
14 |
15 | # Circuito
16 |
17 | # Código
18 |
19 | # Considerações finais
--------------------------------------------------------------------------------
/src/4-Modulo-basico/2-Eletronica-basica.md:
--------------------------------------------------------------------------------
1 | # 4.2 Eletrônica básica
2 |
3 | # Sumário
4 |
5 | 01. [Unidades de medida](#Unidades-de-medida)
6 | 1. [Tensão](#Tensão-Volt)
7 | 0. [Corrente](#Corrente-Ampére)
8 | 0. [Resistência](#Resistência-Ohm)
9 | 00. [Considerações finais](#considerações-finais)
10 |
11 | # Unidades de medida
12 |
13 | ## Tensão (Volt)
14 |
15 | De maneira resumida, a tensão é a DDP (diferença de potencial) entre dois pontos. A unidade utilizada para descrever-la é o **Volt** dada pela sigla V ou U.
16 |
17 |
18 | Normalmente a tensão é fornecida por um gerador. Existe varios tipos de geradores, alguns dos mais comuns são, baterias (pilhas) e placas solares (que nada mais são que geradores fotovoltaicos, que converte luz em energia basicamente).
19 |
20 |
21 | Para facilitar o entendimento, imagine que você tem uma torneira ligada diretamente a uma caixa d'água e precisa que a água saía nela, se você colocar a caixa d'água no mesmo nível da torneira, não haverá diferença de nível, e a água não sairá na torneira. Se você colocar a caixa d'água em um nível mais alto a água saíra. É exatamente essa diferença de altura (diferença de potencial) que faz a água sair do outro lado, ou no nosso caso, a energia.
22 |
23 |
24 | No caso do nosso Arduino podemos usar diferentes tipos de geradores, o nosso computador pode servir como gerador quando utilizamos a entrada USB tipo A, uma bateria pode servir como gerador, desde que tenha pelo menos 9V e ainda podemos utilizar o carregador do nosso celular, desde que não tenha mais que 12V. Essas especificações podem ser lidas no próprio carregador/bateria.
25 |
26 |
27 | No exemplo a baixo é mostrado a alimentação do Arduino feita por uma bateria.
28 |
29 |
30 | 
31 |
32 |
33 | É importante ressaltar que **sempre** deve-se utilizar somente uma fonte de energia. Caso seja utilizada mais de uma, isso pode ocasionar na queima dos componentes da placa, ou caso esteja utilizando a entrada USB, como uma das fontes, pode ocasionar na queima da entrada USB do seu computador, por exemplo.
34 |
35 |
36 | Isso ocorre pois os pinos de alimentação são conectados internamente, uma vez que mais de um gerador (fonte de energia) é utilizado, gera um aumento excessivo na tensão suportada pela placa e fontes externas.
37 |
38 |
39 | Ainda sobre a alimentação através de uma bateria, é possível notar que existem duas "pontas" nela, essas "pontas" são chamadas de polo, onde o negativo leva o símbolo (-) e o positivo o símbolo de (+).
40 |
41 |
42 | Como visto na [aula anterior](/src/4-Modulo-basico/1-Conhecendo), o pino de Vin serve como entrada da fonte de energia e o GND serve como polo negativo. Como estamos utilizando o Vin, **obrigatoriamente** temos que usar pelo menos um polo GND, seja ele qual for, no caso utilizamos o que esta ao lado para facilitar a visualização. Por convenção, o polo positivo utiliza a cor vermelha e o negativo a cor preta.
43 |
44 |
45 | ## Corrente (Ampére)
46 |
47 | Agora que já sabemos o que é tensão, vamos estudar um pouco sobre corrente. A corrente elétrica de maneira resumida, é a movimentação dos elétrons em um determinado material (condutor), isso ocorre devido a DDP (diferença de potencial) entre dois pontos. A corrente nada mais é que a quantidade de carga que passa em um condutor por segundo, também pode ser chamado de coulomb. A unidade utilizada para descrever-la é o **Ampére** dada pela sigla A ou I.
48 |
49 |
50 | Existem dois tipos de corrente, a corrente alternada, que é a básicamente a corrente que flui na tomada de nossa residência, e a corrente contínua que é basicamente a corrente que passa por algum transformador, alguns exemplos de fonte de corrente continua são carregadores de celular, baterias (pilhas) e a entrada USB do computador. Vamos focar a princípio na corrente contínua.
51 |
52 |
53 | No Arduino apenas é possível manipular corrente contínua. Você deve estar se perguntando, é possível fazer acionamento de equipamentos que utilizar corrente alterada? Como por exemplo a lâmpada da minha sala?
54 |
55 |
56 | A resposta para essa pergunta é depende, diretamente pelo Arduino não, mas é possível fazer esse acionamento utilizando componentes que utilizam os dois tipos de energia, que é o caso do relé. A baixo uma imagem de exemplo de um relé.
57 |
58 |
59 | 
60 |
61 |
62 | Nele é possivel notar algumas descrições. A primeira é a sigla "LU-5-R", que é basicamente o modelo deste relé. Mais a baixo temos a descrição "3A/125V AC", vamos separar essa descrição em 3 partes que são "3A", "125V" e "AC", que significam:
63 |
64 |
65 | - 3A -> Significa a corrente máxima suportada por esse relé, a leitura é "3 Amperes";
66 | - 125V -> Signfica a tensão máxima suportada por esse relé, a leitura é "125 Volts";
67 | - AC -> Significa que a corrente que passa por ele é uma corrente **Alternada**.
68 |
69 |
70 | Está é parte do circuito interno dele, significa que a energia que passa por ele pode ter até 3A, 125V em corrente **Alternada** (AC), nessa parte poderiamos conectar uma lâmpada sem problemas. Mas como controlariamos se a lâmpada está acesa ou apagada? Ai entra a segunda parte.
71 |
72 |
73 | Mais a baixo temos a descrição "3A/24V DC", vamos separar novamente, essa descrição em 3 partes que são "3A", "24V" e "DC", que significam:
74 |
75 | - 3A -> Significa a corrente máxima suportada por esse relé, a leitura é "3 Amperes";
76 | - 24V -> Signfica a tensão máxima suportada por esse relé, a leitura é "24 Volts";
77 | - DC -> Significa que a corrente que passa por ele é uma corrente **Contínua**.
78 |
79 |
80 | Está é outra parte do circuito interno dele, significa que a energia que passa por ele pode ter até 3A, 24V em corrente **Contínua** (DC), lembra que o Arduino manipula somente corrente contínua? É aqui que ele entra em ação, essa parte do circuito serve como um interruptor, semelhante ao que utilizamos em nossa residência, porém esse tem o acionamento eletrônico, uma vez que acionarmos ele através do Arduino, ele acenderá ou apagará nossa lâmpada.
81 |
82 |
83 | ## Resistência (Ohm)
84 |
85 | Tendo visto tensão e corrente, vamos seguir para a última grandeza dessa trindade elétrica, mas não menos importante, a resistência. A imagem a seguir ilustra bem a "briga" entre essas 3 grandezas. Essa imagem é amplamente utilizada no ensino de eletrônica básica, logo se torna difícil conhecer a sua origem.
86 |
87 |
88 | 
89 |
90 |
91 | Uma vez que temos a tensão (Volt) e a corrente (Ampére) atuando, se não tivermos algo, ou no caso da imagem alguém, para limitar essa atuação podemos queimar os nossos componentes/equipamentos. A resistência traz uma maior flexibilidade no uso dos componentes/equipamentos. A unidade utilizada para descrever-la é o **Ohm** dada pela letra grega Ω ou ainda a sigla R.
92 |
93 |
94 | A resistência tem como finalidade controlar a passagem de eletróns através de um condutor, seja ele um fio ou não, mais a baixo veremos alguns exemplos de condutores. Esse controle acaba gerando um efeito colateral que é o aquecimento do condutor, esse aquecimento pode ser bom ou ruim, depende da aplicação, por exemplo o chuveiro elétrico, utiliza de uma resistência para aquecer a água.
95 |
96 |
97 | Abaixo um exemplo de um circuito simples com 3 casos diferentes.
98 |
99 |
100 | 
101 |
102 |
103 | Este exemplo pode facilitar o entendimento de como funciona uma resitência. Abaixo como foi feita a ligação desse circuito.
104 |
105 | - 5V -> Representado pelos fios de cor vermelha;
106 | - GND -> Representado pelos fios de cor preta;
107 | - "Placa branca" -> Protoboard, é um tipo de condutor, falaremos melhor dela na [próxima aula](/src/4-Modulo-basico/3-Componentes-eletronicos.md);
108 | - LED da esquerda -> Ligado a um resistor de 300Ω;
109 | - LED do centro -> Ligado a um resistor de 3000Ω ou 3KΩ;
110 | - LED da direita -> Sem resistor.
111 |
112 | Neste circuito é possível notar que todos os 3 leds estão ligados ao 5V e ao GND, a única diferença entre eles são os resistores, uma vez que aumentamos a quantidade de ohms dos resistores os leds tendem a ficar mais fraco, pois quanto maior o número de ohms, mais "apertado" fica o caminho para os eletróns passarem e isso no caso resulta em um led menos "brilhante".
113 |
114 |
115 | No led da direita, quanto retiramos o led, o que acontece é a queima do mesmo, lembra que a resistência tende a aquecer? Quando não utilizamos um resistor, quem aquece é o componente, que no caso é um led e esse aquecimento chega a um ponto que o led simplesmente queima.
116 |
117 |
118 | # Considerações finais
119 |
120 | Para finalizar essa aula, um video complementar (não obrigatório) sobre as três grandezas do canal Mundo da elétrica [link](https://www.youtube.com/watch?v=rDS-W6EQKpk).
121 |
--------------------------------------------------------------------------------
/src/4-Modulo-basico/3-Componentes-eletronicos.md:
--------------------------------------------------------------------------------
1 | # 4.3 Componentes eletrônicos
2 |
3 | # Sumário
4 |
5 | 01. [Unidades de medida](#uma-breve-introdução)
6 | 00. [Resistores](#resistores)
7 | 00. [Capacitores](#capacitores)
8 | 00. [Regulador de tensão](#regulador-de-tensão)
9 | 00. [LED](#led)
10 | 00. [Buzzer](#buzzer)
11 | 00. [Sensores](#sensores)
12 | 00. [Interruptores](#interruptores)
13 | 1. [Relé](#Relé)
14 | 2. [Botões](#Botões)
15 | 00. [Protoboard](#protoboard)
16 | 00. [Considerações finais](##considerações-finais)
17 |
18 | # Uma breve introdução
19 |
20 | O Arduino é uma plataforma que permite a conexão de uma infinidade de componentes eletrônicos, alguns deles serão abordados nesse tópico, porém praticamente todos os componentes usando em circuitos eletrônicos podem ser usados em sua placa. Ainda nesse tópico explicaremos o funcionamento do microcontrolador que é o "cérebro" do nosso Arduino e algumas outras particularidades.
21 |
22 |
23 | # Resistores
24 |
25 | Existem varios tipos de resistores, nesta parte falaremos dos resistores fixos e na [aula 7](/src/4-Modulo-basico/7-Potenciometro+Push.md) falaremos de um tipo de resistor variável. Dentre os resistores fixos existe algumas variações em seus formatos e construções, o intuito aqui é apenas explicar o funcionamento de um resistor.
26 |
27 |
28 | Resistores, de forma simplificada, são responsáveis por diminuir a intensidade da corrente elétrica que passa pelo nosso circuito. Um bom exemplo disso é quando queremos controlar o fluxo de água, imagine um rio, onde queremos diminuir a velocidade com que a água passa, podemos colocar pedras no caminho para diminuir essa velocidade, ou ainda construir uma barragem para regular a quantidade de água que passa por ele. Na eletrônica o princípio é o mesmo, colocamos o resistor para diminuir a velocidade com que os elétrons passam pelo nosso circuito.
29 |
30 |
31 | Existem resistores de diferentes valores de resistência. Assim como a resistência é dadas em **Ohm** dada pela letra grega Ω, o resistores fixos também são classificados utilizando essa medida. Um resistor de 10Ω limita menos a passagem de energia do que um resistor de 300Ω por exemplo.
32 |
33 |
34 | Na imagem a baixo é possível ver 3 resistores, cada um deles tem uma resistência diferente, existe uma tabela de cores que define qual a resistência e a tolerância deles.
35 |
36 |
37 | 
38 |
39 |
40 | Da esquerda para direita temos 300Ω, 1kΩ ou 1000Ω e 10kΩ ou 10000Ω de resistência. Existe uma tabela que explica a relação das cores de um resistor com a a resistência deles, deixarei esse [artigo](https://www.mundodaeletrica.com.br/codigo-de-cores-de-resistores/) com uma explicação completa de como funciona e abaixo um pequeno desafio, você consegue descobrir qual a resistência desses 3 resistores?
41 |
42 |
43 | 
44 |
45 |
46 |
47 | Resposta do desafio
48 |
49 | Para resolver esse desafio utilizaremos a tabela de 4 faixas demonstrada no artigo citado a cima. Ela estará mais a baixo para facilitar o entendimento.
50 |
51 |
52 | 
53 |
54 |
55 | Olhando os resistores de baixo para cima temos as seguintes cores:
56 |
57 | 01. Marrom, verde, marrom e dourado
58 | 00. Marrom, vermelho, vermelho e dourado
59 | 00. Vermelho, preto, vermelho e dourado
60 |
61 | Comparando com a tabela temos o seguinte resultado:
62 |
63 | 01. (1, 5, 1 (0)) e ±5%
64 | 00. (1, 2, 2 (00)) e ±5%
65 | 00. (2, 0, 2 (00)) e ±5%
66 |
67 | Retirando as virgulas e organizando corretamente temos:
68 |
69 | 01. 150Ω e 5% de tolerância
70 | 00. 1200Ω (1.2kΩ) e 5% de tolerância
71 | 00. 2000Ω (2kΩ) e 5% de tolerância
72 |
73 |
74 |
75 | Caso queira uma explicação mais detalhada, esse [vídeo](https://www.youtube.com/watch?v=xK1xe5gsfVk) do canal Mundo da Elétrica, pode auxiliá-lo.
76 |
77 |
78 | Caso queria uma explicação ainda mais detalhada, porém bem mais complexa, recomendo esse [vídeo](https://www.youtube.com/watch?v=e_hU6sAON2U) do canal Ciência Todo Dia.
79 |
80 |
81 | # Capacitores
82 |
83 | Capacitores são componentes eletrônicos que não são muito utilizados em montagem de circuitos com o Arduino, porém são amplamente utilizados em montagem de outros circuitos, é importante saber pelo menos o básico sobre eles, em algum momento você pode acabar esbarrando em um.
84 |
85 |
86 | Capacitores basicamente funcionam como uma bateria, eles tem a capacidade de carregar rapidamente e descarregar rapidamente, ao descarregar eles fornecem uma grande quantidade de carga elétrica para o circuito.
87 |
88 |
89 | Assim como resistores, existem uma infinidade de tipos, modelos e tamanhos. Cada um tem suas particularides, bem como suas características e diferentes utilidades. A princípio iremos falar sobre os capacitores eletrolíticos e cerâmicos.
90 |
91 |
92 | Na imagem a baixo podemos ver dois tipos de capacitores o da esquerda é o eletrolítico e o da direita o cerâmico.
93 |
94 |
95 | 
96 |
97 |
98 | O capacitor eletrolítico tem um formato semelhante a uma pilha, ele é capaz de armazenar maior quantidade de energia que o capacitor eletrolítico, outra diferença principal entre eles é que o capacitor eletrolítico possui polaridade, ou seja ele possui um terminal positivo e um terminal negativo. Existem 2 maneiras de identificar quais são os polos, uma delas é pela faixa branca que fica no plástico que encobre ele, indicando o polo negativo. A outra maneira é através dos terminais "perninhas" dele, o terminal menor é sempre o negativo.
99 |
100 |
101 | Ao manusear capacitores eletrolíticos deve se ter **extremo** cuidado, alguns modelos não possuem proteção caso a corrente não esteja fluindo no sentido correto, existe uma grande possibilidade deles **EXPLODIREM**. Então sempre verifique a polaridade antes de conecta-los em seu circuito.
102 |
103 |
104 | Outro ponto importante quando do manuseamento, sempre verifique a tensão máxima suportada por ele, não deixe que tensões maiores passem por ele, pois pode ocasionar também na **EXPLOSÃO** do mesmo. Tensões menores podem ser usadas sem o menor problema.
105 |
106 |
107 | Nunca os deixem ligados diretamente em uma fonte de energia por demasiado tempo, pois pode ocasionar também na **EXPLOSÃO** do mesmo.
108 |
109 |
110 | Caso queira uma explicação mais detalhada e até um exemplo de explosão do mesmo, esse [vídeo](https://www.youtube.com/watch?v=EBSpmPwo6VQ) do canal Mundo da Elétrica, pode auxiliá-lo.
111 |
112 |
113 | # Regulador de tensão
114 |
115 | Reguladores de tensão podem ser utilizados em circuitos com o Arduino, mas também não são tão comums, o importante é saber como é feita a conversão das tensões utilizadas no Arduino, inclusive em sua placa provavelmente terá pelo menos um desses componentes, uma vez que o Arduino possui um pino para 3.3V e um para 5V.
116 |
117 |
118 | Reguladores de tensão, como o próprio nome já diz tem como objetivo regular a tensão, ou seja diminuir a quantidade de volts que passa por ele. Tentar aumentar a tensão utilizando um regulador de tensão não funcionará, para isso existem circuitos próprios. A baixo mostraremos um exemplo de como funciona um regulador de tensão de 5v.
119 |
120 |
121 | 
122 |
123 |
124 | Na imagem a cima podemos notar que temos uma bateria de 9V, 2 multímetros (que estão dizendo a tensão naquele ponto) e um regulador de tensão de 5v. Os fios de cor amarela e verde, significam o positivo e o negativo, respectivamente, que estão vindo da bateria. Já os fios de cor preta e vermelha, respectivamente, estão correspondendo aos fios que estão saindo do regulador.
125 |
126 |
127 | Notem que no multímetro da esquerdo temos uma tensão de 9V gerada pela bateria, e após o regulador de tensão, no multímetro da direita, temos uma tensão de 5V, no tinkercad ainda existe um regulador de tensão que faria a tensão descer para 3.3V.
128 |
129 |
130 | Existem diferentes tipos de reguladores de tensão, para diferentes finalidades. No nosso Arduino por exemplo, temos 2 ligados aos circuitos de alimentação (no caso do Tinkercad apenas 1) da placa, para que seja possível ter 5V e 3.3V nos pinos correspondentes. A baixo uma imagem de onde podem ficar os reguladores na placa.
131 |
132 |
133 | 
134 |
135 |
136 | Caso queira uma explicação mais detalhada e até um exemplo com varios reguladores, esse [vídeo](https://www.youtube.com/watch?v=JDenESfGj94) do canal Eletrônica Fácil, pode auxiliá-lo.
137 |
138 | # Led
139 |
140 | Leds, de longe, são os componentes mais utilizados no Arduino, existem leds de varias cores (alguns possuem até mais de uma cor), tipos e tamanhos. Alguns entusiastas no assunto, dizem que o led é o parafuso de quem mexe com Arduino, em resumo é um componente indispensável.
141 |
142 | Na imagem a baixo podemos notar basicamente 2 tipos, os de cor única e o RGB. Todo led possui pelo menos um polo positivo e um negativo, por norma, o polo negativo sempre é o menor terminal "perninha". No caso desse led RGB da imagem, ele tem 4 terminais, um negativo e três positivos, cada positivo é referente a uma cor. Em alguns casos, esse led pode ter um positivo e três negativos, mas são casos mais raros.
143 |
144 |
145 | 
146 |
147 |
148 | Falaremos melhor dos leds na [aula 5](/src/4-Modulo-basico/5-Acendendo-LED.md).
149 |
150 | # Buzzer
151 |
152 | Buzzers são componentes que nos permitem emitir um som utilizando o Arduino, não são tão comums de serem utilizados, mas podem ser uma boa solução para emitir um retorno auditivo do que está acontecendo em nossa placa.
153 |
154 |
155 | Buzzers assim como leds, possuem um polo positivo e um negativo, no caso do buzzer você consegue localizar facilmente a indicação de (-) e (+) na parte superior ou em alguns casos na parte inferior do mesmo. Abaixo um exemplo de buzzer.
156 |
157 |
158 | 
159 |
160 |
161 | Caso queira uma explicação mais detalhada, esse [vídeo](https://www.youtube.com/watch?v=LfM8-IDvXo4) do canal Brincando com Ideias, pode auxiliá-lo.
162 |
163 | # Sensores
164 |
165 | Assim como tudo no Arduino, exite uma infinidade de sensores que podem ser utilizados, estarei listando alguns deles aqui, bem como uma breve explicação de seu funcionamento.
166 |
167 |
168 | A princípio iremos utilizar os 3 sensores mostrados na imagem a baixo, que são respectivamente, sensor ultrassônico, sensor de luz (LDR) e o sensor de temperatura (TMP).
169 |
170 |
171 | 
172 |
173 |
174 | O sensor ultrassônico é capaz de medir distâncias através do som, um dos lados dele emite um som e o outro recebe, é feito um calculo e de acordo com o tempo em que leva para esse som voltar ao sensor, é obtida a distância.
175 |
176 |
177 | Caso queira uma explicação mais aprofundada sobre este sensor, esse [vídeo](httpswww.youtube.comwatchv=J_bUAs-VXA8) do canal Laboratório da Julia, pode auxiliá-lo.
178 |
179 | O sensor de luz (LDR) é um tipo de resistência que varia de acordo com a luminosidade, quanto maior a quantidade de luz que incide sobre ele, menor a resistência do mesmo. Você também pode encontrá-los com o nome de fotorresistor.
180 |
181 |
182 | O sensor de temperatura (TMP) tem o funcionamento bem semelhante ao fotorresistor,ele tem um tipo de resistência que varia de acordo com a temperatura, quanto maior a temeperatura no ambiente, menor a resistência do mesmo.
183 |
184 |
185 | # Interruptores
186 |
187 | Basicamente iremos falar sobre 2 tipos de interruptores, Relé e botões, de maneira resumida esses componentes fazem a mesma coisa de maneiras diferentes. Eles basicamente tem como função permitir ou negar que a corrente passe pelo seu circuito, mais a baixo iremos explicar como cada um deles funciona.
188 |
189 |
190 | ## Relé
191 |
192 | O relé é um interruptor interruptor eletromecânico, o seu acionamento é feito através de uma corrente que ao passar por ele faz com que ele seja acionado. Relés são comumente utilizados em estabilizadores elétricos e automóveis.
193 |
194 |
195 | Em um relé é possível que seja passado mais de um tipo de corrente, como o visto na [aula 2](/src/4-Modulo-basico/2-Eletronica-basica.md), onde seu acionamento era feito por corrente contínua porém a corrente que passava por ele para o acionamento da lâmpada era de corrente alternada. A baixo uma imagem de um relé
196 |
197 |
198 |
199 |
200 |
201 |
202 | No lado direito dele é possível notar um desenho que mostra um tipo de mola alguns pontos e um fio que passa por essa mola. A mola em questão é responsável pelo acionamento do mesmo, ao ser energizada, o estado dele passa do que é chamado de normalmente fechado para o normalmente aberto, permitido que uma corrente de uma outra fonte possa passar por ele por exemplo.
203 |
204 |
205 |
206 | 
207 |
208 |
209 |
210 | ## Botões
211 |
212 | Botões são componentes bem simples e que possuem uma grande variedade, o interruptor que você utiliza para ligar a luz de um cômodo da sua casa é um tipo de botão por exemplo. Na [aula 7](/src/4-Modulo-basico/7-Potenciometro+Push.md) falaremos melhor sobre eles.
213 |
214 |
215 | No Arduino Uno por padrão vem um botão soldado nele, esse botão é do tipo push button, ele é acionado somente enquanto eles está sendo pressionado, enquanto está sendo pressionado a energia flui entre seus terminais, uma vez que é soltado a energia deixa de fluir através dele.
216 |
217 |
218 |
219 | 
220 |
221 |
222 |
223 | # Protoboard
224 |
225 | A protoboard não necessariamente é um componente, mas ela auxilia e muito na hora de montarmos nossos circuitos. Existe uma certa quantidade de tipos de protoboard, na maioria dos casos somente o número de pinos é a real mudança. A baixo um exemplo de uma protoboard 400.
226 |
227 |
228 |
229 | 
230 |
231 |
232 | Na parte superior e inferior temos os pinos que de - e +, esses pinos tem uma ligação interna na horizontal, ou seja se você conectar algo no primeiro pino negativo, a corrente flui até o ultimo e também nos seus intermediários, e a mesma coisa acontece com o positivo.
233 |
234 |
235 | No centro da protoboard temos os pinos que vão de a1 até 30j, nesses pinos, ao contrario dos pinos - e +, a corrente flui na vertical, porem eles são limitados.
236 | **Exemplo 1:** Se for conectado algo ao pino 1a a corrente só ira fluir até o 1e, em qualquer um dos outros pinos, nessa faixa (1b, 1c e 1d), a corrente também fluirá.
237 | **Exemplo 2:** Se for conectado algo ao pino 1j a corrente só ira fluir até o 1f, em qualquer um dos outros pinos, nessa faixa (1i, 1h e 1g), a corrente também fluirá.
238 |
239 |
240 | # Considerações Finais
241 |
242 | Esses são somente uma parte dos componentes eletrônicos, existem uma infinidades de tipos e tamanhos dos mesmos. Deixarei ainda um video complementar do canal Manual do Mundo que pode ser encontrado [aqui](https://www.youtube.com/watch?v=C54Cp819Ebc)
243 |
--------------------------------------------------------------------------------
/src/4-Modulo-basico/4-Estrutura.md:
--------------------------------------------------------------------------------
1 | # 4.04 Estrutura de um programa .ino
2 |
3 | # Sumário
4 |
5 | 01. [O que é um programa com extensão ino](#O-que-é-um-programa-com-extensão-ino)
6 | 00. [Estrutura](#Estrutura)
7 | 00. [Funções](#funções)
8 | 1. [Funções de uso geral](#funções-de-uso-geral)
9 | 1. [pinMode();](#pinmode)
10 | 0. [delay();](#delay)
11 | 0. [millis();](#millis)
12 | 0. [Funções de comunicação serial](#funções-de-comunicação-serial)
13 | 0. [Funções utilizadas com os pinos digitais](#funções-utilizadas-com-os-pinos-digitais)
14 | 1. [digitalWrite();](#digitalwrite)
15 | 0. [digitalRead();](#digitalread)
16 | 0. [Funções utilizadas com os pinos analógicos](#funções-utilizadas-com-os-pinos-analógicos)
17 | 1. [analogWrite();](#analogwrite)
18 | 0. [analogRead();](#analogread)
19 |
20 | # O que é um programa com extensão ino
21 |
22 | Antes de falarmos sobre a estrutura do programa .ino, vamos falar o que exatamente seria esse programa. O arquivo com extensão .ino é o arquivo gerado pela ide do Arduino e é ele que é carregado no microcontrolador da nossa placa.
23 |
24 |
25 | # Estrutura
26 |
27 | Um programa .ino, assim como um programa em C/C++, tem uma estrutura básica na qual dentro dela desenvolvemos nosso programa. A baixo um exemplo de como é a estrutura básica.
28 |
29 | ```C++
30 | //Carrega a biblioteca com as funções do Arduino
31 | //Em algumas IDE's não é necessária a declaração explicita dessa biblioteca
32 | #include "Arduino.h"
33 |
34 | //Bloco do programa que é executado apenas uma vez
35 | //Normalmente é utilizado para definir os pinos como entrada ou saída
36 | void setup(){
37 |
38 | }
39 |
40 | //Bloco do programa que fica em execução enquanto o Arduino estiver ligado
41 | //Tudo que estiver dentro dele ficará sendo executado repetidamente
42 | void loop(){
43 |
44 | }
45 | ```
46 |
47 | # Funções
48 |
49 | Agora iremos falar sobre algumas das funções utilizadas dentro do nosso programa, caso queira uma lista completa você pode encontra-lá no site oficial do Arduino ou através desse [link.](https://www.arduino.cc/reference/pt/)
50 |
51 | # Funções de uso geral
52 |
53 | ## pinMode();
54 |
55 | Sintaxe: pinMode(pino, modo);
56 |
57 | A função pinMode(); tem como finalidade definir o modo de operação de um pino. Para isso é utilizado o parâmetro que diz qual o número do pino e em seguida **INPUT** ou **OUTPUT**. A baixo um exemplo de utilização.
58 |
59 |
60 | ```C++
61 | #include "Arduino.h"
62 |
63 | void setup(){
64 | //Define o pino 13 como saída
65 | pinMode(13, OUTPUT);
66 | //Define o pino 12 como entrada
67 | pinMode(12, INPUT);
68 | }
69 | ```
70 | Normalmente essa função é utilizada dentro do void setup(), já que o modo de operação só precisa ser definido uma vez.
71 |
72 |
73 | ## delay();
74 |
75 | Sintaxe: delay(tempo em milissegundos);
76 |
77 | A função delay(); tem como finalidade pausar por completo a execução do programa no Arduino durante o tempo que foi inserido como parâmetro. A baixo um exemplo de utilização.
78 |
79 |
80 | ```C++
81 | #include "Arduino.h"
82 |
83 | void setup(){
84 | //Define o pino 13 como saída
85 | pinMode(13, OUTPUT);
86 | }
87 |
88 | void loop(){
89 | //Define que a tensão pode passar no pino 13
90 | digitalWrite(13, HIGH);
91 | //Aguarda 1000ms ou 1 segundo
92 | delay(1000);
93 | //Define que a tensão não pode passar no pino 13
94 | digitalWrite(13, LOW);
95 | //Aguarda 500ms ou 0.5 segundo
96 | delay(500);
97 | }
98 | ```
99 |
100 | ## millis();
101 |
102 | Sintaxe: millis();
103 |
104 | A função millis(); retorna o quantos milissegundos já passaram desde a inicialização do Arduino, pode ser usado como o delay(), porém está função não pausa o programa. A baixo um exemplo de utilização.
105 |
106 |
107 | ```C++
108 | #include "Arduino.h"
109 |
110 | //Declaração da variável tempo que recebe o tempo atual
111 | unsigned long int tempo = millis();
112 |
113 | void setup(){
114 | pinMode(13, OUTPUT);
115 | }
116 |
117 | void loop(){
118 | //Se a diferença tempo (atual - tempo antigo)
119 | //for menor que 500 mantem o led aceso
120 | if((millis() - tempo) < 500){
121 | //Define que a tensão pode passar no pino 13
122 | digitalWrite(13, HIGH);
123 | }
124 | //Caso contrario apaga o led
125 | else{
126 | //Define que a tensão não pode passar no pino 13
127 | digitalWrite(13, LOW);
128 | }
129 |
130 | // Verifica se já passou 1500 milisegundos
131 | if((millis() - tempo) > 1500){
132 | //Redefine a variável tempo
133 | tempo = millis();
134 | }
135 | }
136 | ```
137 |
138 | Essa função é um pouco mais complexa de ser utilizada, porém ela traz a vantagem de não pausa por completo a execução do programa.
139 |
140 |
141 | # Funções de comunicação serial
142 |
143 | As funções de comunicação serial são amplamente utilizadas quando queremos enviar mensagens de um Arduino para o outro ou até mesmo mostrar algo no monitor serial de nossa IDE, no [projeto 3](/src/Projetos/3-Projeto-Rede.md) iremos falar melhor delas, a baixo um exemplo de como podem ser utilizadas.
144 |
145 |
146 | ```C++
147 | #include "Arduino.h"
148 |
149 | void setup(){
150 | //Define a velocidade da comunicação serial
151 | //Obrigatório essa definição com o mesmo valor
152 | //tanto no receptor quanto no emissor
153 | Serial.begin(9600);
154 | }
155 |
156 | void loop(){
157 | //Declaração da variável recebido
158 | char recebido;
159 | //Escreve na comunicação serial o valor 1;
160 | Serial.write('1');
161 | //Verifica se tem algum dado para ser lido pela comunicação serial
162 | if(Serial.available()){
163 | //Define a variavel recebido com o valor que foi lido
164 | recebido = Serial.read();
165 | }
166 | }
167 | ```
168 |
169 | # Funções utilizadas com os pinos digitais
170 |
171 | ## digitalWrite();
172 |
173 | Sintaxe: digitalWrite(pino, valor);
174 |
175 | A função digitalWrite(); tem como finalidade definir o estado de um pino digital. Para isso é utilizado o parâmetro que diz qual o número do pino e em seguida **HIGH** ou **LOW**, ou ainda pode ser usado respectivamente **1** ou **0**. A baixo um exemplo de utilização com ambos os casos.
176 |
177 |
178 | ```C++
179 | #include "Arduino.h"
180 |
181 | void setup(){
182 | //Define o pino 13 como saída
183 | pinMode(13, OUTPUT);
184 | }
185 |
186 | void loop(){
187 | //Define que a tensão pode passar no pino 13
188 | digitalWrite(13, HIGH);
189 | //Define que a tensão não pode passar no pino 13
190 | digitalWrite(13, LOW);
191 |
192 | //Define que a tensão pode passar no pino 13
193 | digitalWrite(13, 1);
194 | //Define que a tensão não pode passar no pino 13
195 | digitalWrite(13, 0);
196 | }
197 | ```
198 | Normalmente essa função é utilizada dentro do void loop(), já que essa manipulação, normalmente, é feita mais de uma vez durante a execução do programa, mas nada impede de utiliza-la no void setup().
199 |
200 |
201 | ## digitalRead();
202 |
203 | Sintaxe: digitalRead(pino);
204 |
205 | A função digitalRead(); tem como finalidade ler o estado de um pino digital. Para isso é utilizado somente o parâmetro que diz qual o número do pino. A baixo um exemplo de utilização.
206 |
207 |
208 | ```C++
209 | #include "Arduino.h"
210 |
211 | void setup(){
212 | //Define o pino 13 como saída
213 | pinMode(13, OUTPUT);
214 | }
215 |
216 | void loop(){
217 | //Se a tensão estiver passando no pino 13
218 | if(digitalRead(13) == HIGH){
219 | //Define que a tensão não pode passar no pino 13
220 | digitalWrite(13, LOW);
221 | }
222 |
223 | //Se a tensão não estiver passando no pino 13
224 | if(digitalRead(13) == LOW){
225 | //Define que a tensão pode passar no pino 13
226 | digitalWrite(13, HIGH);
227 | }
228 | }
229 | ```
230 | Normalmente essa função é utilizada dentro do void loop(), já que essa manipulação, normalmente, é feita mais de uma vez durante a execução do programa.
231 |
232 |
233 | # Funções utilizadas com os pinos analógicos
234 |
235 | ## analogWrite();
236 |
237 | Sintaxe: analogWrite(pino, valor)
238 |
239 | A função analogWrite(); tem como finalidade definir o estado de um pino analógico. Para isso é utilizado o parâmetro que diz qual o número do pino e em seguida um valor que pode variar de 0 a 255, essa função pode ser utilizada tanto nos pinos PWM quanto nos pinos analógicos. A baixo um exemplo de utilização.
240 |
241 |
242 | ```C++
243 | #include "Arduino.h"
244 |
245 | void setup(){
246 | //Define o pino analógico 0 como saída
247 | pinMode(A0, OUTPUT);
248 | }
249 |
250 | void loop(){
251 | //Define que a tensão não pode passar no pino 13
252 | analogWrite(A0, 0);
253 | //Define que parte da tensão pode passar
254 | analogWrite(A0, 120);
255 | //Define que a tensão total pode passar
256 | analogWrite(A0, 255);
257 | }
258 | ```
259 | Essa função é comumente utilizada quando se quer controlar a intensidade de um led.
260 |
261 |
262 | ## analogRead();
263 |
264 | Sintaxe: analogRead(pino);
265 |
266 | A função analogWrite(); tem como ler o valor de um pino analógico. Para isso é utilizado o parâmetro que diz qual o número do pino e em seguida um valor que pode variar de 0 a 1024. A baixo um exemplo de utilização.
267 |
268 |
269 | ```C++
270 | #include "Arduino.h"
271 |
272 | void setup(){
273 | //Define a velocidade da comunicação serial
274 | //Obrigatório essa definição com o mesmo valor
275 | //tanto no receptor quanto no emissor
276 | Serial.begin(9600);
277 | //Define o pino analógico 0 como entrada
278 | pinMode(A0, INPUT);
279 | }
280 |
281 | void loop(){
282 | //Lê o valor da porta analógica 0 e mostra no monitor serial
283 | Serial.println(analogRead(A0));
284 | }
285 | ```
286 |
--------------------------------------------------------------------------------
/src/4-Modulo-basico/5-Acendendo-LED.md:
--------------------------------------------------------------------------------
1 | # 4.5 Acendendo um LED
2 |
3 | # Sumário
4 |
5 | 01. [Introdução](#introdução)
6 | 00. [Circuito](#circuito)
7 | 00. [Código](#código)
8 | 00. [Considerações finais](#considerações-finais)
9 |
10 | # Introdução
11 |
12 | Esta aula tem como finalidade agregar o conhecimento adquirido na aulas anteriores em um pequeno projeto inicial, que será o de acender um led e com isso serão passados 2 projetos para complementar a aula.
13 |
14 |
15 | # Circuito
16 |
17 | Requisitos para montar o circuito:
18 |
19 | - 1 Arduino Uno (Ou algum outro de preferência);
20 | - 1 Protoboard (Opcional);
21 | - 1 LED (Qualquer cor);
22 | - 1 Resistor de 300Ω;
23 | - Alguns jumpers (Se você estiver usando a placa fisicamente).
24 |
25 |
26 | Inicialmente estaremos montando o circuito da maneira mostrada a baixo, dentro do possível experimente outras maneiras.
27 |
28 |
29 | 
30 |
31 |
32 | # Código
33 |
34 | ```C++
35 | #include
36 |
37 | void setup(){
38 | pinMode(8, OUTPUT);
39 | }
40 |
41 | void loop(){
42 | digitalWrite(8, HIGH);
43 | delay(1000);
44 | digitalWrite(8, LOW);
45 | delay(1000);
46 | }
47 | ```
48 |
49 | Com esse código, o seu Arduino deverá enviar comandos para que led fique acendendo e apagando a cada 1 segundo, caso tenha dúvida em relação as funções utilizadas recomendo que revise a [aula 4](4-Estrutura.md) lá é falado detalhadamente sobre as funções.
50 |
51 | Você pode ver o projeto funcionando através desse [link](https://www.tinkercad.com/things/cDS3L45QDAz).
52 |
53 |
54 | # Considerações finais
55 |
56 | Agora que você já sabe acender um led, ficam aqui dois projetos para você praticar seus conhecimentos, é sempre de grande ajuda tentar montar o projeto proposto sem olhar o código inicial, mas caso tenha dificuldade não exite em consultar. Os projetos propostos são os seguintes:
57 |
58 | 01. [Projeto Semáforo](../Projetos/1-Projeto-semaforo.md)
59 | 00. [Projeto RGB](../Projetos/2-Projeto-RGB.md)
60 |
61 | Lembrando que ao fim de cada projeto proposto há um desafio para que você exercite ainda mais, boa sorte =)
--------------------------------------------------------------------------------
/src/4-Modulo-basico/6-IO.md:
--------------------------------------------------------------------------------
1 | # 4.6 Entrada e Saída (Comunicação serial)
2 |
3 | # Sumário
4 |
5 | 01. [Introdução](#introdução)
6 | 00. [O que é a comunicação serial](#comunicação-serial)
7 | 00. [Circuito](#circuito)
8 | 00. [Código](#código)
9 | 00. [Considerações finais](#considerações-finais)
10 |
11 | # Introdução
12 |
13 | Esta aula tem como finalidade apresentar uma funcionalidade do Arduino, a comunicação serial, e por fim deixar um projeto para que você treine seus conhecimentos.
14 |
15 |
16 | # Comunicação serial
17 |
18 | A Comunicação serial é usada em varios dispositivos, a impressora é um bom exemplo, os dados são passados para ela através desse tipo de comunicação.
19 |
20 |
21 | Esse tipo de comunicação depende de uma conexão de 2 vias, uma via de envio (TX) e uma de recebimento (RX). No arduino é possível localizar 2 pinos, o pino 0 que recebe a sigla RX e o pino 1 que recebe a sigla TX.
22 |
23 |
24 | Quando estamos montando um circuito que desejamos que haja essa comunicação, devemos ligar de forma invertida esses pinos:
25 |
26 | - RX (0) do Arduino 1 no TX (1) do Arduino 2;
27 | - RX (0) do Arduino 2 no TX (1) do Arduino 1.
28 |
29 | **É de extrema importância que haja uma ligação GND do Arduino 1 com GND do Arduino 2 para que a comunicação fiquei sincronizada, caso contrário a comunicação não irá funcionar.**
30 |
31 | A baixo irei demonstrar um circuito com essas conexões.
32 |
33 |
34 | # Circuito
35 |
36 | Requisitos para montar o circuito:
37 |
38 | - 2 Arduino Uno (Ou algum outro de preferência);
39 | - Alguns jumpers (Se você estiver usando a placa fisicamente).
40 |
41 |
42 | Inicialmente estaremos montando o circuito da maneira mostrada a baixo, dentro do possível experimente outras maneiras.
43 |
44 |
45 | 
46 |
47 |
48 | # Código
49 |
50 | **Esse código deve ser inserido no Arduino 1**
51 |
52 | ```C++
53 | void setup()
54 | {
55 | //Iniciando comunicação serial com frequência de 9600
56 | //A frequência deve ser a mesma em ambos os Arduinos
57 | Serial.begin(9600);
58 | //Inicia a comunicação enviando um valor para o outro Arduino
59 | Serial.write('1');
60 | }
61 |
62 | void loop(){
63 | //Checa se existe algo no buffer da comunicação serial
64 | if(Serial.available()){
65 | //Envia a informação recebida de volta
66 | Serial.write(Serial.read());
67 | delay(1000);
68 | }
69 | }
70 | ```
71 |
72 | **Esse código deve ser inserido no Arduino 2**
73 |
74 | ```C++
75 | void setup()
76 | {
77 | //Iniciando comunicação serial com frequência de 9600
78 | //A frequência deve ser a mesma em ambos os Arduinos
79 | Serial.begin(9600);
80 | }
81 |
82 | void loop(){
83 | //Checa se existe algo no buffer da comunicação serial
84 | if(Serial.available()){
85 | //Envia a informação recebida de volta
86 | Serial.write(Serial.read());
87 | delay(1000);
88 | }
89 | }
90 | ```
91 |
92 | Para visualizar a informação que está sendo enviada você precisa utilizar o monitor serial, no Arduino IDE pode ser acessado através do atalho **Ctrl+Shift+M**, ou como na imagem a baixo:
93 |
94 |
95 | 
96 |
97 |
98 | No tinkercad basta clicar em Monitor serial no canto inferior esquerdo da aba código.
99 |
100 |
101 | 
102 |
103 |
104 | Com esse código, o seus Arduinos deverão enviar a mesma informação um para o outros, tenha dúvida em relação as funções utilizadas recomendo que revise a [aula 4](4-Estrutura.md) lá é falado detalhadamente sobre as funções.
105 |
106 | Você pode ver o projeto funcionando através desse [link](https://www.tinkercad.com/things/ebSZS8MG4IE).
107 |
108 |
109 | # Considerações finais
110 |
111 | Agora que você já sabe como funciona a comunicação serial, fica aqui um projeto para você praticar seus conhecimentos, é sempre de grande ajuda tentar montar o projeto proposto sem olhar o código inicial, mas caso tenha dificuldade não exite em consultar. O projetos proposto é o seguinte:
112 |
113 | 01. [Projeto rede de Arduinos (Comunicação Serial)](../Projetos/3-Projeto-Rede.md)
114 |
115 | Boa sorte =)
--------------------------------------------------------------------------------
/src/4-Modulo-basico/7-Potenciometro+Push.md:
--------------------------------------------------------------------------------
1 | # 4.7 Potênciometro e Push Button
2 |
3 | # Sumário
4 |
5 | 01. [Potenciômetro](#potenciômetro)
6 | 00. [Push button](#push-button)
7 | 00. [Circuito](#circuito)
8 | 00. [Código](#código)
9 | 00. [Considerações finais](#considerações-finais)
10 |
11 | # Potenciômetro
12 |
13 | Como dito na [aula 3](/src/4-Modulo-basico/3-Componentes-eletronicos.md) existem alguns tipos de resistências variáveis, uma delas é o potenciômetro.
14 |
15 | Os potenciômetros por sua vez possuem basicamente 3 tipos: giratório, deslizante e trimpot, nesta aula iremos abordar apenas o tipo giratório.
16 |
17 | Esse tipo de potenciômetro tem como característica principal ter 3 polos, um positivo, um VDC (que é o pino responsável pela medição da resistência), e o pino GND, e um eixo giratório no qual através do seu movimento é variada a resistência do mesmo. Como ilustrado pela figura abaixo:
18 |
19 |
20 | 
21 |
22 |
23 | Essa figura foi retirada do site kitsarduino, mais precisamente nesse [artigo](https://www.kitsarduino.com.br/cmp/potenciometro.html) que fala sobre potenciômetros.
24 |
25 | # Push button
26 |
27 | Como dito na [aula 3](/src/4-Modulo-basico/3-Componentes-eletronicos.md) o push button é acionado somente enquanto ele está sendo pressionado, ele basicamente converte um acionamento mecânico em um acionamento elétrico.
28 |
29 | Existem 3 tipos de acionamento que são:
30 | - Resistor Pull-down;
31 | - Resistor Pull-up;
32 | - Pull-up do Arduino.
33 |
34 | No nosso circuito iremos utilizar somente o "Pull-up do Arduino". Nesse modo, o sinal digital que será enviado ao Arduino ao pressionar o botão será o de LOW.
35 |
36 | Existem alguns tipos diferentes de push button, alguns possuem 2 terminais e alguns possuem 4 como o do exemplo abaixo:
37 |
38 |
39 | 
40 |
41 |
42 | No caso do push button de 4 terminais, os que estão sinalizados com as bolinhas de mesma cor fecham o contato quando o botão é pressionado.
43 |
44 | # Circuito
45 |
46 | Requisitos para montar o circuito:
47 |
48 | - 1 Arduino Uno (Ou algum outro de preferência);
49 | - 1 Protoboard (Opcional);
50 | - 1 Push button;
51 | - 1 Potênciometro de 10kΩ;
52 | - Alguns jumpers (Se você estiver usando a placa fisicamente).
53 |
54 |
55 | Inicialmente estaremos montando o circuito da maneira mostrada abaixo, dentro do possível experimentar outras maneiras.
56 |
57 |
58 | 
59 |
60 |
61 | # Código
62 |
63 | ``` C++
64 | //Pino onde o botão está conectado
65 | #define _BUTTON_ 7
66 | void setup()
67 | {
68 | //Inicia a comunicação serial
69 | Serial.begin(9600);
70 | //Define o pino do botão como entrada e pullup
71 | pinMode(_BUTTON_, INPUT_PULLUP);
72 |
73 | }
74 |
75 | void loop()
76 | {
77 | //Se o botão for pressionado
78 | if (!digitalRead(_BUTTON_))
79 | {
80 | //Lê o valor da porta analógica 0 e mostra no monitor serial
81 | Serial.println(analogRead(A0));
82 | delay(500);
83 | }
84 | }
85 | ```
86 |
87 | Ao pressionar o botão uma mensagem será enviada ao monitor serial informando a leitura do potenciômetro, essa leitura será algo entre 0 e 1023, para visualizar a informação que está sendo enviada você precisa utilizar o monitor serial, caso não se lembre como abrir-lo, visite a [aula 6](/src/4-Modulo-basico/6-IO.md) novamente, ao fim da explicação do código utilizado estão listadas as maneiras de abrir-lo.
88 |
89 | Você pode ver o projeto funcionando através desse [link](https://www.tinkercad.com/things/bFtR4J7POYo).
90 |
91 | # Considerações finais
92 |
93 | Com esse projeto é possível montar algumas outras funcionalidades, você consegue pensar em alguma? Pratique com ele e na próxima aula terá a indicação de um projeto utilizando um potenciômetro e um servo. No [artigo](https://www.kitsarduino.com.br/cmp/potenciometro.html) citado no início dessa aula também existe um exemplo que pode ser usado como prática. Boa sorte =)
94 |
95 |
--------------------------------------------------------------------------------
/src/4-Modulo-basico/8-Servo-motor.md:
--------------------------------------------------------------------------------
1 | # 4.8 Servo motor
2 |
3 | # Sumário
4 |
5 | 01. [Introdução](#introdução)
6 | 00. [Servo Motor](#servo-motor)
7 | 00. [Circuito](#circuito)
8 | 00. [Código](#código)
9 | 00. [Considerações finais](#considerações-finais)
10 |
11 | # Introdução
12 |
13 | # Servo motor
14 |
15 | # Circuito
16 |
17 | # Código
18 |
19 | # Considerações finais
--------------------------------------------------------------------------------
/src/4-Modulo-basico/9-Temperatura.md:
--------------------------------------------------------------------------------
1 | # 4.9 Sensor de temperatura
2 |
3 | # Sumário
4 |
5 | 01. [Introdução](#introdução)
6 | 00. [Sensor de temperatura](#sensor-de-temperatura)
7 | 00. [Circuito](#circuito)
8 | 00. [Código](#código)
9 | 00. [Considerações finais](#considerações-finais)
10 |
11 | # Introdução
12 |
13 | # Sensor de temperatura
14 |
15 | # Circuito
16 |
17 | # Código
18 |
19 | # Considerações finais
--------------------------------------------------------------------------------
/src/5-Modulo-intermediario/Conexao-i2c.md:
--------------------------------------------------------------------------------
1 | # 5. Conexão I2C
2 |
3 | # Sumário
4 |
5 | 01. [Introdução](#introdução)
6 | 00. [Conexão I2C](#conexão-i2c)
7 | 00. [Circuito](#circuito)
8 | 00. [Código](#código)
9 | 00. [Considerações finais](#considerações-finais)
10 |
11 | # Introdução
12 |
13 | # Conexão I2C
14 |
15 | # Circuito
16 |
17 | # Código
18 |
19 | # Considerações finais
--------------------------------------------------------------------------------
/src/5-Modulo-intermediario/LCD.md:
--------------------------------------------------------------------------------
1 | # 5. Display LCD
2 |
3 | # Sumário
4 |
5 | 01. [Introdução](#introdução)
6 | 00. [Display LCD](#display-lcd)
7 | 00. [Circuito](#circuito)
8 | 00. [Código](#código)
9 | 00. [Considerações finais](#considerações-finais)
10 |
11 | # Introdução
12 |
13 | # Display LCD
14 |
15 | # Circuito
16 |
17 | # Código
18 |
19 | # Considerações finais
--------------------------------------------------------------------------------
/src/5-Modulo-intermediario/Sensor-Ultrassonico.md:
--------------------------------------------------------------------------------
1 | # 5. Sensor Ultrassonico
2 |
3 | # Sumário
4 |
5 | 01. [Introdução](#introdução)
6 | 00. [Sensor Ultrassonico](#sensor-ultrassonico)
7 | 00. [Circuito](#circuito)
8 | 00. [Código](#código)
9 | 00. [Considerações finais](#considerações-finais)
10 |
11 | # Introdução
12 |
13 | # Sensor Ultrassonico
14 |
15 | # Circuito
16 |
17 | # Código
18 |
19 | # Considerações finais
--------------------------------------------------------------------------------
/src/5-Modulo-intermediario/Teclado-matricial.md:
--------------------------------------------------------------------------------
1 | # 5. Teclado Matricial
2 |
3 | # Sumário
4 |
5 | 01. [Introdução](#introdução)
6 | 00. [Teclado Matricial](#teclado-matricial)
7 | 00. [Circuito](#circuito)
8 | 00. [Código](#código)
9 | 00. [Considerações finais](#considerações-finais)
10 |
11 | # Introdução
12 |
13 | # Teclado Matricial
14 |
15 | # Circuito
16 |
17 | # Código
18 |
19 | # Considerações finais
--------------------------------------------------------------------------------
/src/Projetos/Basico/0-Projeto-blink.md:
--------------------------------------------------------------------------------
1 | # P.0 Testando o ambiente
2 |
3 | Feito todas as configurações necessárias, caso não tenha feito ainda, ou queira revisar o ambiente, aqui vai alguns atalhos:
4 |
5 | - [Configurando o Ambiente Windows](/src/2-Ambiente/1-Ambiente-windows.md)
6 | - [Configurando o Ambiente Linux](/src/2-Ambiente/2-Ambiente-linux.md)
7 | - [Configurando o Ambiente Online](/src/2-Ambiente/3-Ambiente-online.md)
8 |
9 | Certo disso, vamos ao primeiro projeto, não se preocupe, o código para esse projeto já vem incluso na IDE do Arduino e no Tinkercad. Sabendo disso, vamos ao que interessa.
10 |
11 |
12 | ## Projeto blink
13 |
14 | O projeto blink é basicamente o nosso "Hello World!", caso você não saiba, o "Hello World!" é tido como o projeto inicial para todo programador quando inicia em uma nova linguagem, alguns programadores dizem que se você não o fizer as coisas tendem a dar errado, então não vamos arriscar não é mesmo?
15 |
16 |
17 |
18 | Utilizando a Arduino IDE
19 |
20 | Ponto importante antes de enviar o código para a placa é verificar em qual porta COM está, irei explicar como verificar da maneira mais simples.
21 |
22 |
23 | Na barra superior ao clicar em Tools -> Port, podemos verificar que, **no meu caso**, temos dois dispositivos conectados na porta USB que permitem comunicação serial, um deles pode ser a placa, para verificar qual é de fato, basta despluga-la e uma sumirá, sendo assim fica fácil de localizar qual é a porta certa.
24 |
25 |
26 | 
27 |
28 |
29 | **Observação importante 1, caso nenhuma suma, pode ser algo ocasionado por falta de software de driver, é de extrema importância a localização do mesmo. Cada placa possui um software de driver, então nesse caso é melhor fazer uma busca pela internet por qual seria o software driver mais aconselhado para sua placa.**
30 |
31 |
32 | **Observação importante 2, ainda na opção Tools, temos a opção "Board", é de extrema importância que o modelo de placa selecionado, seja o modelo da sua placa, caso contrário o código pode não subir, ou subir com falhas. A baixo uma imagem de exemplo de quando uma placa está selecionada.**
33 |
34 |
35 |
36 | 
37 |
38 |
39 | Na Arduino IDE, este código já vem por padrão, assim como uma infinidade de outros códigos, para encontrá-lo basta seguir o caminho Files -> Examples -> 01.Basics -> Blink, como na imagem a seguir:
40 |
41 |
42 | 
43 |
44 |
45 | Feito isso uma nova janela aparecerá com o código, basta fazer o upload do mesmo, clicando no icone de seta para a direita, como mostrado a baixo.
46 |
47 |
48 | 
49 |
50 |
51 | Caso tudo esteja correto uma mensagem com "Done uploading" como esta, deverá aparecer na barra inferior da IDE:
52 |
53 |
54 | 
55 |
56 |
57 | Após feito o upload, se tudo correr bem, o LED "L" que é o led imbutido do Arduino deverá começar a piscar, mas porque? Veremos mais a baixo
58 |
59 |
60 | 
61 |
62 |
63 | Caso algo dê errado, volte esse passo a passo do começo, não se esqueça de verificar o cabo que liga o Arduino ao PC e a instalação dos drivers =)
64 |
65 |
66 | A explicação superficial deste código e porque o LED está piscando, está mais a baixo na seção "Código explicado", na [aula 4](/src/4-Modulo-basico/zEm-desenvolvimento.md) iremos aprofundar melhor em como ele funciona.
67 |
68 |
69 |
70 |
71 | Utilizando o Tinkercad
72 |
73 | No Tinkercad esse projeto já vem por padrão quando você insere o Arduino no ambiente de trabalho, irei mostrar como inserir o Arduino e como checar o código que está sendo executado dentro do Arduino.
74 |
75 |
76 | Você já deve saber como criar um novo circuito, caso não se lembre irei recapitular a parte de configuração do [ambiente online](/src/2-Ambiente/3-Ambiente-online.md). Para criar um novo projeto utilizando o arduino basta clicar na aba "Circuitos" (1) no canto esquerdo e em seguida "Criar novo Circuito"(2)
77 |
78 | 
79 |
80 |
81 | Após criar um novo projeto, no canto direito é possível localizar uma barra de pesquisa (1), digite Arduino, como na imagem a baixo. No resultado deverá aparecer o "Arduino Uno R3" (2), basta clicar na figura dele e depois clica na parte branca da tela (3) para adicionar o Arduino ao seu ambiente de trabalho.
82 |
83 |
84 | 
85 |
86 |
87 | Após adicionar o Arduino ao ambiente de trabalho, basta clicar no botão "Iniciar simulação" (1), repare que 2 leds na placa se acenderam, o LED que indica que o Arduino está ligado, "ON" (2) e o LED "L" (3) este LED em questão estará piscando, mas porque? Veremos mais a baixo.
88 |
89 |
90 | 
91 |
92 |
93 | Ao clicarmos em "Código" (1), podemos visualizar como o algoritmo funciona (2), os passos descritos ali são seguidos durante a execução do programa que está rodando no Arduino. Ao clicarmos em "Blocos" (3), temos a opção "Texto" que é a opção que mais iremos utilizar.
94 |
95 |
96 | 
97 |
98 |
99 | Ao selecionar a opção "Texto" uma mensagem como essa irá surgir, basta clicar em "Continuar":
100 |
101 |
102 | 
103 |
104 |
105 | E por fim veremos um código (1) como na imagem a baixo:
106 |
107 |
108 | 
109 |
110 |
111 | A explicação superficial deste código e porque o LED está piscando, está mais a baixo na seção "Código explicado", na [aula 4](/src/4-Modulo-basico/zEm-desenvolvimento.md) iremos aprofundar melhor em como ele funciona.
112 |
113 |
114 |
115 |
116 | Código explicado
117 |
118 | ```C++
119 | //Esta parte do codigo é executada somente uma vez
120 | void setup()
121 | {
122 | //Define o pino onde o LED está internamente ligado como saida
123 | pinMode(LED_BUILTIN, OUTPUT);
124 | }
125 | //Fim da parte que é executada somente uma vez
126 |
127 |
128 | //Esta parte do codigo é executada enquanto o Arduino estiver energizado
129 | void loop()
130 | {
131 | //Inicio
132 |
133 | //Define a porta do LED como ligada
134 | digitalWrite(LED_BUILTIN, HIGH);
135 | //Pausa a execução por 1 segundo
136 | delay(1000);
137 | //Define a porta do LED como desligada
138 | digitalWrite(LED_BUILTIN, LOW);
139 | //Pausa a execução por 1 segundo
140 | delay(1000);
141 |
142 | //Volta para o inicio
143 | }
144 | //Fim da parte que é executada enquanto o Arduino estiver energizado
145 | ```
146 |
147 | O LED interno do Arduino pisca pois o código faz com que em um momento, o estado do LED seja definido como ligado, aguarda 1 segundo, define como desligado e aguarda 1 segundo. Como tudo que está dentro de "void loop(){}" fica sendo repetido até que o Arduino seja desligado, ele ficara piscando infinitamente.
148 |
149 |
--------------------------------------------------------------------------------
/src/Projetos/Basico/1-Projeto-semaforo.md:
--------------------------------------------------------------------------------
1 | # P.1 Projeto semáforo
2 |
3 |
4 | ## Objetivo do projeto
5 | Esse projeto tem como finalidade, introduzir melhor os conceitos sobre lógica de programação e fixar os conhecimentos adquiridos na [aula 5](/src/4-Modulo-basico/5-Acendendo-LED.md).
6 |
7 |
8 | ## O que o projeto deve ter?
9 |
10 | O projeto consiste em basicamente um mini semáforo para o trânsito e para os pedestres, o projeto pode ser feito utilizando os seguintes materiais:
11 |
12 |
13 | - 1 Arduino Uno (Ou algum outro de preferência);
14 | - 1 Protoboard (Opcional);
15 | - 5 LEDs (2 Vermelhos, 2 Verdes e 1 Amarelo);
16 | - 1 Resistor de 300Ω;
17 | - Alguns jumpers (Se você estiver usando a placa fisicamente);
18 |
19 |
20 | Inicialmente estaremos montando o circuito da maneira mostrada a baixo, dentro do possível experimente outras maneiras.
21 |
22 |
23 | 
24 |
25 |
26 | Você é capaz de fazê-lo funcionar? Uma resposta para o programa estará mais a baixo, porém tente fazê-lo a principio sem consulta-la.
27 |
28 |
29 | Código que pode resolver o problema
30 |
31 | ```C++
32 | //Definindo constantes para os pinos dos leds do trânsito
33 | #define _PIN_RED_T 13
34 | #define _PIN_YELLOW_T 12
35 | #define _PIN_GREEN_T 11
36 |
37 | //Definindo constantes para os pinos dos leds do pedestre
38 | #define _PIN_RED_P 10
39 | #define _PIN_GREEN_P 9
40 |
41 | void setup()
42 | {
43 | //Setando os pinos digitais que vamos utilizar como saida
44 | //e desligando/apagando os LEDS
45 | for(int i = 9; i<14;i++){
46 | pinMode(i, OUTPUT);
47 | digitalWrite(i, LOW);
48 | }
49 | }
50 |
51 | void loop()
52 | {
53 | //Inicio
54 |
55 | //Apagando LED pedestre verde
56 | digitalWrite(_PIN_GREEN_P, LOW);
57 | //Apagando LED trânsito vermelho
58 | digitalWrite(_PIN_RED_T, LOW);
59 | //Acendendo LED pedestre vermelho
60 | digitalWrite(_PIN_RED_P, HIGH);
61 | //Acendendo LED trânsito verde
62 | digitalWrite(_PIN_GREEN_T, HIGH);
63 | //Esperando 5 segundos
64 | delay(5000);
65 |
66 | //Apagando LED trânsito verde
67 | digitalWrite(_PIN_GREEN_T, LOW);
68 | //Acendendo LED trânsito amarelo
69 | digitalWrite(_PIN_YELLOW_T, HIGH);
70 | //Esperando 2 segundo
71 | delay(1000);
72 |
73 | //Apagando LED trânsito amarelo
74 | digitalWrite(_PIN_YELLOW_T, LOW);
75 | //Acendendo LED trânsito vermelho
76 | digitalWrite(_PIN_RED_T, HIGH);
77 | //Apagando LED pedestre vermelho
78 | digitalWrite(_PIN_RED_P, LOW);
79 | //Acendendo LED pedestre verde
80 | digitalWrite(_PIN_GREEN_P, HIGH);
81 | //Esperando 3 segundos
82 | delay(3000);
83 |
84 | //Volta pro inicio
85 | }
86 | ```
87 |
88 |
89 |
90 | Você pode ver o projeto funcionando através desse [link](https://www.tinkercad.com/things/2XFrNsnj5kG-arduino-um-mini-semaforo).
91 |
92 |
93 | ## Desafio
94 |
95 | O desafio proposto é o de adicionar mais um semáforo, tanto para o pedestre quando para o trânsito, imagine que temos um cruzamento de duas vias e precisamos controlar os dois lados, você é capaz de resolver esse problema? Espero que sim, boa sorte =)
96 |
97 |
98 |
99 | 
100 |
101 |
102 | [A resposta para o desafio final vai estar nessa linha caso tenha curiosidade =)](https://www.tinkercad.com/things/6xkGVtYL2qp)
--------------------------------------------------------------------------------
/src/Projetos/Basico/2-Projeto-RGB.md:
--------------------------------------------------------------------------------
1 | # P.2 Projeto LED RGB
2 |
3 | ## Objetivo do projeto
4 | Esse projeto tem como finalidade aprofundar os conhecimentos adquiridos na [aula 5](/src/4-Modulo-basico/5-Acendendo-LED.md).
5 |
6 |
7 | ## O que o projeto deve ter?
8 |
9 | O projeto consiste em basicamente um led RGB que em cada tempo acende em uma determinada cor, para isso iremos utilizar os seguintes materiais:
10 |
11 |
12 | - 1 Arduino Uno (Ou algum outro de preferência);
13 | - 1 Protoboard (Opcional);
14 | - 1 LED RGB;
15 | - 1 Resistor de 300Ω;
16 | - Alguns jumpers (Se você estiver usando a placa fisicamente);
17 |
18 |
19 | Inicialmente estaremos montando o circuito da maneira mostrada a baixo, dentro do possível experimente outras maneiras.
20 |
21 |
22 | 
23 |
24 |
25 | Você é capaz de fazê-lo funcionar? Uma resposta para o programa estará mais a baixo, porém tente fazê-lo a principio sem consulta-la.
26 |
27 |
28 | Código que pode resolver o problema
29 |
30 | ```C++
31 | //Definindo constantes para os pinos de cada cor do led
32 | #define _PIN_RED 13
33 | #define _PIN_BLUE 12
34 | #define _PIN_GREEN 11
35 |
36 |
37 | void setup()
38 | {
39 | //Setando os pinos digitais que vamos utilizar como saida
40 | //e desligando/apagando os LEDS
41 | for(int i = 9; i<14;i++){
42 | pinMode(i, OUTPUT);
43 | digitalWrite(i, LOW);
44 | }
45 | }
46 |
47 | void loop()
48 | {
49 | //Inicio
50 |
51 | //Apagando LED na cor verde
52 | digitalWrite(_PIN_GREEN, LOW);
53 | //Acendendo LED na cor vermelha
54 | digitalWrite(_PIN_RED, HIGH);
55 | //Esperando 2 segundos
56 | delay(2000);
57 |
58 | //Apagando LED na cor vermelha
59 | digitalWrite(_PIN_RED, LOW);
60 | //Acendendo LED na cor azul
61 | digitalWrite(_PIN_BLUE, HIGH);
62 | //Esperando 2 segundos
63 | delay(2000);
64 |
65 | //Apagando LED na cor azul
66 | digitalWrite(_PIN_BLUE, LOW);
67 | //Acendendo LED na cor verde
68 | digitalWrite(_PIN_GREEN, HIGH);
69 | //Esperando 2 segundos
70 | delay(2000);
71 |
72 | //Volta pro inicio
73 | }
74 | ```
75 |
76 |
77 |
78 | Você pode ver o projeto funcionando através desse [link](https://www.tinkercad.com/things/cBMCX1IzppZ).
79 |
80 |
81 | ## Desafio
82 |
83 | Como de costume, temos um desafio, o desafio da vez é o de adicionar mais cores ao led, uma dica é misturar as cores, você é capaz de resolver esse problema? Espero que sim, boa sorte =)
84 |
85 |
86 | [Algumas das cores que consegui vão estar nessa linha caso tenha curiosidade =)](https://www.tinkercad.com/things/kJYF72AkiXI)
--------------------------------------------------------------------------------
/src/Projetos/Basico/3-Projeto-Rede.md:
--------------------------------------------------------------------------------
1 | # P.3 Projeto rede de Arduinos
2 |
3 | ## Objetivo do projeto
4 |
5 | Esse projeto tem como finalidade aprofundar os conhecimentos adquiridos na [aula 5](/src/4-Modulo-basico/5-Acendendo-LED.md) e [aula 6](/src/4-Modulo-basico/6-IO.md)
6 |
7 | ## O que o projeto deve ter?
8 |
9 | O projeto consiste em basicamente dois Arduinos enviando mensagem um para o outro e fazendo dois LEDs piscarem sincronizadamente:
10 |
11 |
12 | - 2 Arduino Uno (Ou algum outro de preferência);
13 | - 2 Protoboard (Opcional);
14 | - 2 LEDs;
15 | - 2 Resistores de 300Ω;
16 | - Alguns jumpers (Se você estiver usando a placa fisicamente);
17 |
18 |
19 | Inicialmente estaremos montando o circuito da maneira mostrada a baixo, dentro do possível experimente outras maneiras.
20 |
21 |
22 | 
23 |
24 |
25 | Você é capaz de fazê-lo funcionar? Uma resposta para o programa estará mais a baixo, porém tente fazê-lo a principio sem consulta-la.
26 |
27 |
28 | Código que pode resolver o problema
29 |
30 | Arduino 1:
31 |
32 | ```C++
33 | void setup(){
34 | //Iniciando comunicação serial com frequência de 9600
35 | Serial.begin(9600);
36 | //Escrevendo na comunicação serial para iniciar o algoritmo
37 | Serial.write('1');
38 | //Definindo o pino 8 como saída
39 | pinMode(8, OUTPUT);
40 | }
41 |
42 | void loop(){
43 | //Variável do tipo char que armazena o dado recebido
44 | char recebido;
45 | //Checa se existe algo no buffer da comunicação serial
46 | if(Serial.available()){
47 | //Armazena o dado na variável
48 | recebido = Serial.read();
49 | //Se o valor recebido for 1
50 | if(recebido == '1'){
51 | //Define a porta 8 como ligada
52 | digitalWrite(8, HIGH);
53 | //Envia a ordem para o outro arduino acender
54 | Serial.write('1');
55 | }
56 | else if (recebido == '0'){
57 | //Define a porta 8 como desligada
58 | digitalWrite(8, LOW);
59 | //Envia a ordem para o outro arduino apagar
60 | Serial.write('0');
61 | }
62 | //Espera 1 segundo
63 | delay(1000);
64 | }
65 | }
66 | ```
67 |
68 | Arduino 2:
69 | ```C++
70 | void setup(){
71 | //Iniciando comunicação serial com frequência de 9600
72 | Serial.begin(9600);
73 | //Definindo o pino 8 como saída
74 | pinMode(8, OUTPUT);
75 | }
76 |
77 | void loop(){
78 | //Variável do tipo char que armazena o dado recebido
79 | char recebido;
80 | //Checa se existe algo no buffer da comunicação serial
81 | if(Serial.available()){
82 | //Armazena o dado na variável
83 | recebido = Serial.read();
84 | //Se o valor recebido for 1
85 | if(recebido == '1'){
86 | //Define a porta 8 como ligada
87 | digitalWrite(8, HIGH);
88 | //Envia a ordem para o outro arduino apagar
89 | Serial.write('0');
90 | }
91 | else if (recebido == '0'){
92 | //Define a porta 8 como desligada
93 | digitalWrite(8, LOW);
94 | //Envia a ordem para o outro arduino acender
95 | Serial.write('1');
96 | }
97 | //Espera 1 segundo
98 | delay(1000);
99 | }
100 | }
101 | ```
102 |
103 |
104 |
105 |
106 | Você pode ver o projeto funcionando através desse [link](https://www.tinkercad.com/things/7wJXkrIwREG).
107 |
--------------------------------------------------------------------------------
/src/Projetos/Basico/4-Projeto-controle-servo.md:
--------------------------------------------------------------------------------
1 | # P.4 Projeto controle de um servo motor através de um potênciometro
2 |
3 | ## Objetivo do projeto
4 |
5 | Esse projeto tem como finalidade aprofundar os conhecimentos adquiridos na [aula 7](/src/4-Modulo-basico/7-Potenciometro.md) e [aula 8](/src/4-Modulo-basico/8-Servo-motor.md)
6 |
7 | ## O que o projeto deve ter?
8 |
9 | O projeto consiste em basicamente um servor motor que deve ser controlado utilizando um potênciometro:
10 |
11 |
12 | - 1 Arduino Uno (Ou algum outro de preferência);
13 | - 1 Protoboard (Opcional);
14 | - 1 Servo motor;
15 | - 1 Potênciometro (No caso usaremos de 1KΩ, mas pode ser de outra medida, isso só interferirá na precisão do movimento);
16 | - Alguns jumpers (Se você estiver usando a placa fisicamente);
17 |
18 |
19 | Inicialmente estaremos montando o circuito da maneira mostrada a baixo, dentro do possível experimente outras maneiras.
20 |
21 |
22 | 
23 |
24 |
25 | Você é capaz de fazê-lo funcionar? Uma resposta para o programa estará mais a baixo, porém tente fazê-lo a principio sem consulta-la.
26 |
27 |
28 | Código que pode resolver o problema
29 |
30 | ```C++
31 | //Inclui a biblioteca com funções para o servo
32 | #include
33 |
34 | //Instância um objeto do tipo Servo
35 | Servo servoMotorObj;
36 |
37 | //Define qual pino faz a leitura do potenciômetro
38 | #define _PIN_POTENCIOMETRO_ 0
39 |
40 | //Define qual o pino controla o servo
41 | #define _PIN_SERVO_ 4
42 |
43 | void setup()
44 | {
45 | //Seta o pino do servo ao objeto de tipo servo
46 | servoMotorObj.attach(_PIN_SERVO_);
47 | }
48 |
49 | //Definido uma variavel para a leitura do potenciômetro
50 | int leituraPotenciometro;
51 |
52 | void loop()
53 | {
54 | //Inicio
55 | //Faz a leitura do valor do potenciômetro e armazena o valor
56 | leituraPotenciometro = analogRead(_PIN_POTENCIOMETRO_);
57 | //Pega o valor da leitura e faz uma regra de 3 com o valor de 180
58 | //180 seria relacionado ao grau maximo que o servomecanismo suporta
59 | leituraPotenciometro = map(leituraPotenciometro, 0, 1023, 0, 180);
60 | //Define no objeto a angulação
61 | servoMotorObj.write(leituraPotenciometro);
62 | //Pausa o programa por 10 milésimos de segundo
63 | delay(10);
64 |
65 | //Volta para o inicio
66 | }
67 | ```
68 |
69 |
70 |
71 | Você pode ver o projeto funcionando através desse [link](https://www.tinkercad.com/things/eq0WrMoQxxx).
72 |
73 |
74 | ## Desafio
75 |
76 | Como de costume, temos um desafio, o desafio da vez é o de adicionar mais alguns servos, você é capaz de resolver esse problema? Espero que sim, boa sorte =)
77 |
78 |
79 | [Algumas das cores que consegui vão estar nessa linha caso tenha curiosidade =)](https://www.tinkercad.com/things/k7Dux258KN1)
--------------------------------------------------------------------------------
/src/Projetos/Basico/5-Projeto-termometro.md:
--------------------------------------------------------------------------------
1 | # P.5 Projeto Termômetro
2 |
3 | ## Objetivo do projeto
4 |
5 | ## O que o projeto deve ter?
6 |
7 | ## Desafio
8 |
--------------------------------------------------------------------------------
/src/Projetos/Intermediario/Projeto-calculadora.md:
--------------------------------------------------------------------------------
1 | # P. Projeto calculadora
2 |
3 | ## Objetivo do projeto
4 |
5 | ## O que o projeto deve ter?
6 |
7 | ## Desafio
8 |
--------------------------------------------------------------------------------
/src/Projetos/Intermediario/Projeto-rede-i2c.md:
--------------------------------------------------------------------------------
1 | # P. Projeto rede de Arduinos (Comunicação I2C)
2 |
3 | ## Objetivo do projeto
4 |
5 | ## O que o projeto deve ter?
6 |
7 | ## Desafio
8 |
--------------------------------------------------------------------------------
/src/Projetos/Intermediario/Projeto-sensor.md:
--------------------------------------------------------------------------------
1 | # P. Projeto sensor de estacionamento
2 |
3 | ## Objetivo do projeto
4 |
5 | ## O que o projeto deve ter?
6 |
7 | ## Desafio
8 |
--------------------------------------------------------------------------------
/src/imgs/Auxi/construction.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Auxi/construction.png
--------------------------------------------------------------------------------
/src/imgs/Auxi/ino.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Auxi/ino.png
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/AcendendoLed/Circuito.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/AcendendoLed/Circuito.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Componentes/BotaoArduino.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Componentes/BotaoArduino.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Componentes/Buzzer.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Componentes/Buzzer.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Componentes/Capacitores.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Componentes/Capacitores.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Componentes/Leds.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Componentes/Leds.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Componentes/ProtoboardLimpa.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Componentes/ProtoboardLimpa.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Componentes/Regulador_5v.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Componentes/Regulador_5v.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Componentes/Regulador_Arduino.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Componentes/Regulador_Arduino.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Componentes/ReleDetalhes.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Componentes/ReleDetalhes.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Componentes/Resistores.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Componentes/Resistores.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Componentes/Resistores_desafio.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Componentes/Resistores_desafio.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Componentes/Sensores.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Componentes/Sensores.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Eletronica-basica/AlimentacaoComBateria.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Eletronica-basica/AlimentacaoComBateria.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Eletronica-basica/LeiDeOhm.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Eletronica-basica/LeiDeOhm.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Eletronica-basica/Rele.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Eletronica-basica/Rele.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Eletronica-basica/Resistores.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Eletronica-basica/Resistores.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/IO/Circuito.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/IO/Circuito.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/IO/IDE.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/IO/IDE.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/IO/Tinkercad.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/IO/Tinkercad.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Uno/Uno.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Uno/Uno.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Uno/UnoEsq.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Uno/UnoEsq.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Uno/UnoInf.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Uno/UnoInf.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/Uno/UnoSup.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/Uno/UnoSup.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/push-potenciometro/Circuito.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/push-potenciometro/Circuito.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/push-potenciometro/potenciometro.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/push-potenciometro/potenciometro.jpg
--------------------------------------------------------------------------------
/src/imgs/ModuloBasico/push-potenciometro/push.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/ModuloBasico/push-potenciometro/push.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/0-blink/IDE_Boards.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/0-blink/IDE_Boards.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/0-blink/IDE_Porta.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/0-blink/IDE_Porta.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/0-blink/IDE_Selecionando_example.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/0-blink/IDE_Selecionando_example.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/0-blink/IDE_Upload.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/0-blink/IDE_Upload.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/0-blink/IDE_Upload_Done.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/0-blink/IDE_Upload_Done.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/0-blink/tinkercad_arduino.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/0-blink/tinkercad_arduino.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/0-blink/tinkercad_arduino_alert.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/0-blink/tinkercad_arduino_alert.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/0-blink/tinkercad_arduino_blink.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/0-blink/tinkercad_arduino_blink.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/0-blink/tinkercad_arduino_cod.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/0-blink/tinkercad_arduino_cod.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/0-blink/tinkercad_arduino_cod_blocks.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/0-blink/tinkercad_arduino_cod_blocks.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/0-blink/tinkercad_led_aceso.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/0-blink/tinkercad_led_aceso.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/1-semaforo/Semaforo.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/1-semaforo/Semaforo.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/1-semaforo/Semaforo_Desafio.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/1-semaforo/Semaforo_Desafio.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/2-RGB/Esquema.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/2-RGB/Esquema.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/3-Rede/Esquema.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/3-Rede/Esquema.jpg
--------------------------------------------------------------------------------
/src/imgs/Projetos/4-Servo/Esquema.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Projetos/4-Servo/Esquema.jpg
--------------------------------------------------------------------------------
/src/imgs/TinkerCad/Continuar.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/TinkerCad/Continuar.jpg
--------------------------------------------------------------------------------
/src/imgs/TinkerCad/CriandoCircuito.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/TinkerCad/CriandoCircuito.jpg
--------------------------------------------------------------------------------
/src/imgs/TinkerCad/CriarConta.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/TinkerCad/CriarConta.jpg
--------------------------------------------------------------------------------
/src/imgs/TinkerCad/Final.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/TinkerCad/Final.jpg
--------------------------------------------------------------------------------
/src/imgs/TinkerCad/Inscrever.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/TinkerCad/Inscrever.jpg
--------------------------------------------------------------------------------
/src/imgs/TinkerCad/Opcoes.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/TinkerCad/Opcoes.jpg
--------------------------------------------------------------------------------
/src/imgs/Unix/Site.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Unix/Site.jpg
--------------------------------------------------------------------------------
/src/imgs/Win/ArduinoIde.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Win/ArduinoIde.jpg
--------------------------------------------------------------------------------
/src/imgs/Win/DownloadExe.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Win/DownloadExe.jpg
--------------------------------------------------------------------------------
/src/imgs/Win/DownloadZip.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Win/DownloadZip.jpg
--------------------------------------------------------------------------------
/src/imgs/Win/JustDownload.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/senhorbento/Arduino4noobs/5a9e75728edd33aa57fbb1f7bdb1722c329d9644/src/imgs/Win/JustDownload.jpg
--------------------------------------------------------------------------------