Princípios da Programação

Glossário

digital -> Sinal Digital. Pode ser 0 ou 5 Volts.

analog -> Sinal Analógico. Pode ser um valor entre 0 e 5 Volts.

read -> Ler/Retornar.

write -> Escrever/Informar.

pin -> Pino/GPIO do Arduino.

GPIO -> General Purpose Input Output, ou, Pinos de entrada e saída de propósitos gerais.

PWM -> Pino da saída analógica

delay -> Atraso.

HIGH -> Valor máximo/ligar

LOW -> Valor mínimo/desligar

Milisegundo -> 1000 milissegundos equivale a 1 segundo.

GND -> Negativo/Terra/Ground.

VCC -> Positivo/5 Volts

if -> Condição

else -> Se a condição for falsa

for -> Estrutura de repetição

Abrir chave -> {

Fechar chave -> }

Escopo -> Trecho de código que está entre 2 chaves. Ex: {codigo}

Serial -> Comunicação serial entre o Arduino e o Computador.

= -> Para atribuir algum valor.

== -> Para comparar 2 valores. Muito usado no if

Declarar -> Criar/instanciar.

1 Byte -> 8 bits

true -> Verdadeiro/1

false -> Falso/0

Funções Obrigatórias

Todo código para Arduino deve conter 2 funções obrigatórias, que são: void setup() e void loop().

void setup(){
}

void loop(){
}

O void setup() só é executado uma vez, e é executado antes do void loop(). Geralmente, o void loop() é usado para configurações de portas, configuração da comunicação serial, dentre outros comandos que só precisam ser executados uma vez.

O void loop() é executado após o void setup(), e é destinado para comandos que precisam ser executados infinitamente.

Comandos Básicos

pinMode(pino, tipo); -> Define o tipo do pino. Ex: INPUT(entrada de energia), OUTPUT(saida de energia), INPUT_PULLUP(entrada GND).

digitalWrite(pino, estado); -> Controla a energia de saída em algum pino. Podendo ser HIGH(ligado) ou LOW(desligado).

analogWrite(pino, valor); -> Define o valor analógico de saída para um pino PWM, sendo 0 para 0 Volts e 255 para 5 Volts.

delay(tempo em milisegundos); -> Atraso de tempo em milissegundos para a linha ser executada.

map(valor base, valor mínimo do valor base, valor máximo do valor base, valor mínimo de saída, valor máximo de saída); -> Retorna um valor após fazer uma regra de três composta.

analogRead(pino analógico); -> Retorna um valor analógico de um pino de entrada analógica. Lê o valor do pino analógico.

digitalRead(pino); -> Retorna um valor digital de algum pino de entrada digital. Lê o valor do pino digital.

millis() -> Retorna o tempo em milissegundos que o Arduino está ligado.

Na maioria dos casos, é necessário colocar um ; no final do comando para o Arduino saber que o comando chegou ao final.

Um comando é uma função que pode ser invocada/chamada a qualquer momento para realizar determinada tarefa.

Alguns comandos aceitam outros comandos dentro.
Ex: map(analogRead(pino), 0, 255, 0, 100);
Nesse exemplo, o comando analogRead() está dentro do comando map(). Neste caso, não é necessário colocar o ; no comando analogRead(), pois o “comando principal” é o map(). Sendo assim, o ; é colocado no final do map().

Comentários

Um comentário é um texto(palavra, frase, alguma explicação) que não é executado pelo Arduino(não é compilado). Você pode usar um comentário para fazer observações no seu código e melhorar o entendimento do que você está fazendo.

O comentário em bloco pode ser usado para comentar várias linhas. Esse tipo de comentário se estende desde a abertura do comentário (/*) até o fechamento do comentário (*/).

Tudo que está após o // é um comentário em linha, ou seja, o comentário vai desde o // até o final da linha

/*
este é
um comentário
em bloco
*/

//Este é um comentário em linha

void setup(){
pinMode(13, OUTPUT); //Pino 13 definido como saida de energia
}

void loop(){
digitalWrite(13, HIGH); // Energizando o pino 13
delay(1000); //Atraso de 1 segundo
digitalWrite(13, LOW); // Desligando o pino 13
delay(1000); //Atraso de 1 segundo

/* Código para fazer o LED
da porta 13 piscar */
}

Condições

Para verificar uma ou mais condições, é usado o if. A condição está dentro dos parênteses, caso for verdadeiro, o código dentro do escopo do if será executado. Se for falso e tenha um else depois do if, o código que está dentro do escopo do else será executado.

O operador lógico == serve para comparar 2 valores. Se os dois valores forem iguais, retorna verdadeiro/true.

Operador lógico != serve para comparar 2 valores. Se os dois valores forem diferentes, retorna verdadeiro/true.

Operador lógico < serve para comparar 2 valores. Se o primeiro valor for menor que o segundo, retorna verdadeiro, true;

Operador lógico > serve para comparar 2 valores. Se o primeiro valor for maior que o segundo, retorna verdadeiro, true;

O operador lógico && serve para fazer duas ou mais comparações. Se todas a comparações forem verdadeiras, retorna verdadeiro/true.

O operador lógico || serve para fazer duas ou mais comparações. Se pelo menos uma das comparações for verdadeira, retorna verdadeiro/true.

Exemplos:

if(3 == 3){
//O código que está nesse escopo será executado
}

if("Arduino" == "Arduino"){
//O código que está nesse escopo será executado
}else{
//O código que está nesse escopo não será executado
}

if(5 == 8){
//O código que está nesse escopo não será executado
}else{
//O código que está nesse escopo será executado
}

if(5 != 1){
//O código que está nesse escopo será executado
}

if(5 != 5){
//O código que está nesse escopo não será executado
}

if(5 > 1){
//O código que está nesse escopo será executado
}

if(5 < 1){
//O código que está nesse escopo não será executado
}

if(7 == 7 && 5 > 1){
//O código que está nesse escopo será executado
}

if(7 == 7 && 5 != 5){
//O código que está nesse escopo não será executado
}

if(7 == 5 || 5 != 5){
//O código que está nesse escopo será executado
}

if(7 == 3 || 5 > 5){
//O código que está nesse escopo não será executado
}

Comunicação Serial

A Comunicação Serial é uma forma do Arduino se comunicar com o computador durante a execução do código.

Serial.begin(9600); // Para iniciar uma comunicação Serial na velocidade 9600.

Serial.print("Olá"); // Enviando a mensagem "Olá" para o computador sem pular linha.

Serial.println("Olá"); // Enviando a mensagem "Olá" para o computador e pulando uma linha.

if(Serial.available()) {
} // Verificando se tem nova mensagem na comunicação Serial. Nesse caso, uma mensagem enviado do computador para o Arduino.

Serial.readString(); //Retorna a mensagem da Serial no tipo String.

Serial.parseInt(); //Retorna a mensagem da Serial no tipo Int.

Estrutura de Repetição

A Comunicação Serial é uma forma do Arduino se comunicar com o computador durante a execução do código.

for (inicialização; condição; incremento) {
//comandos;
}

for (int i = 0; i < 10; i++) {
//O código desse escopo vai se repetir 5 vezes;
}

Variáveis

Variável, como o nome diz, é algo em que o valor pode variar com o passar do tempo. Cada tipo de variável ocupa um determinado espaço na memória.

Variáveis do tipo número:

byte -> Ocupa 8 bits (1 bytes). Valores de 0 até 255

int -> Ocupa 16 bits (2 bytes). Valores de -32.768 até 32.767

unsigned int -> Ocupa 16 bit (2 byte). Valores de 0 até 65.535

long -> Ocupa 32 bits (4 bytes). Valores de -2.147.483.648 até 2.147.483.647

unsigned long -> Ocupa 32 bits (4 bytes). Valores de 0 até 4.294.967.295

float -> Ocupa 32 bit (4 byte). Valores de -3,4028235 E+38 até 3,4028235 E+38
Variáveis do tipo texto:

char -> Ocupa 8 bit (1 byte). A quantidade de caracteres(letras) é limitado.

String -> O tamanho varia de acordo com a quantidade de caracteres.
Variável do tipo Verdadeira ou Falsao:

Boolean ou bool -> Ocupa 1 byte. Essa variável só pode receber 2 tipos de valores, que é 1 ou 0, "true" ou "false".
Declaração da Variável:

variável nome = valor;

Exemplos:

int quantidade = 17;
float preco = 8.75;
string nome = "Vinicius";
bool sucesso = true;

string nome; //Nesse exemplo, a variável é declarada mas não é atribuido nenhum valor.
int numero; //Nesse exemplo, a variável é declarada mas não é atribuido nenhum valor.
Mudando o valor da variável:

int quantidade = 10; //Criação da variável
quantidade = 18; //Mudando o valor da variável

float preco = 7.15; //Criação da variável
preco = 2.83; //Mudando o valor da variável

string nome; //Criação da variável sem atribuir valor
string nome = "Arduino"; //Mudando o valor da variável

int numero; //Criação da variável sem atribuir valor
numero = 18; //Mudando o valor da variável

Exemplos

int led = 13;

void setup(){
pinMode(led, OUTPUT);
}

void loop(){
digitalWrite(led, HIGH);
delay(1000);
digitalWrite(led, LOW);
delay(1000);
}
int numero = 13;
int texto;

void setup(){
Serial.begin(9600);
texto = "Arduino";
}

void loop(){
Serial.print(numero);
Serial.print(" - ");
Serial.print(texto);
Serial.print(" - Tempo: ");
Serial.println(millis());
}
int numero = 13;
int valor = 10;

void setup(){
Serial.begin(9600);
}

void loop(){
if(numero != 13 || valor < 20){
Serial.println("Coreto");
}else{
Serial.println("Falso");
}
}
void setup(){
Serial.begin(9600);
}

void loop(){
if(Serial.available()) {
String text_serial = Serial.readString();
Serial.print("A mensagem foi: ");
Serial.println(text_serial);
}
}
int pino = A0;

void setup(){
Serial.begin(9600);
pinMode(pino, INPUT);
}

void loop(){
Serial.print("Valor: ");
Serial.println(analogRead(pino));
}