- Essa função inicia o gerador de números pseudo-aleatórios, fazendo-o começar a contagem a partir de um valor arbitrário. Essa sequência, embora muito longa e aleatória, é sempre a mesma.
Se a sequência de números gerados pela função numeroAleatorio() precisa ser diferente em execuções consecutivas do código, utilize entradas razoavelmente aleatórias, como a função lerAnalogico() em um pino desconectado, como parâmetro do gerardor.
Entretanto, caso seja útil estabelecer sequências pseudo-aleatórias que se repetem com exatidão, é possível utilizar a função geradorAleatorio() com uma constante como parâmetro.

 Ex.:
  numeroLongo numeroAleat;

  configuracao() {
   USB.conectar(9600);
   geradorAleatorio(lerAnalogico(0));
  }

  principal() {
   numeroAleat = numeroAleatorio(300);
    USB.enviar(numeroAleat);
    USB.enviar("\n");
    esperar(50);
   }

- Essa função retorna um valor pseudo-aleatório. É possível utilizar esse comando passando dois parâmetros de execução, o valor mínimo(incluído no intervalo aleatório) e o valor máximo(excluído do intervalo) a ser gerado pela função.

 Ex.:
  numeroLongo numeroAleat;

  configuracao() {
   USB.conectar(9600);
   geradorAleatorio(lerAnalogico(0));
  }

  principal() {
   numeroAleat = numeroAleatorio(300);
    USB.enviar(numeroAleat);
    USB.enviar("\n");
    esperar(50);
   }

 Igual a.

 Ex.:
  se(x==y){
   //...
  }

 Menor que.

 Ex.:
  enquanto(x<10){
   //...
  }

 Menor que ou igual.

 Ex.:
  enquanto(x<=10){
   //...
  }

 Maior que.

 Ex.:
  se(x>y){
   //...
  }

 Maior que ou igual.

 Ex.:
  faca{
   //...
  }
  enquanto(x>=y)

 Diferente de.

 Ex.:
  faca{
   //...
  }
  enquanto(x!=y)

 É um operador lógico e resulta em “Verdadeiro” se ambas as condições de entrada serem verdadeiras. Se uma ou as duas forem “Falso” ela irá retornar “Falso”.

 Ex.:
  numero botao = 9;
  numero botao2 = 10;

  configuracao() {
   definirModo(botao, SAIDA);
   definirModo(botao2, SAIDA);
   USB.conectar(9600);
  }
  principal() {
   se((lerDigital(botao)==LIGADO) e (lerDigital(botao2)==LIGADO){
    USB.enviarln(“Dois botoes pressionados”);
    esperar(500);
   }
  }

 É um operador lógico e retorna “Verdadeiro” se um ou os dois dos valores de entrada forem verdadeiros. Ele retorna “Falso” se ambos resultados recebidos forem falsos.

 Ex.:
  numero botao = 9;
  numero botao2 = 10;

  configuracao() {
   definirModo(botao, SAIDA);
   definirModo(botao2, SAIDA);
   USB.conectar(9600);
  }
  principal() {
   se((lerDigital(botao)==LIGADO) ou (lerDigital(botao2)==LIGADO){
    USB.enviarln(“Pelo menos um botao pressionado”);
    esperar(500);
   }
  }

 Compara se uma Palavra começa com outra Palavra com retorno booleano de 1 ou 0

 Sintaxe:
minhaPalavra.comecaCom(comparacao);

 Ex.:
  configuracao() {
   USB.conectar(9600); // Inicia uma comunicação serial
  }
  principal() {
   // Inicia uma variável com a Palavra minhaPalavra com valor 123456
   Palavra minhaPalavra = "123456";
   // Inicia uma variável com a Palavra comparacao com valor 123
   Palavra comparacao = "123";
   // Verifica se a minhaPalavra começa com 123
   USB.enviarln(minhaPalavra.comecaCom(comparacao));
   // Retorna 1 no monitor serial
  }

 Retorna o número de milissegundos passados desde que a placa Arduino começou a executar o programa atual. Sua marcação é muito boa para pequenos periodos de tempo, em casos de tempos maiores (como minutos ou horas) é recomendado o uso de outras soluções (como um Real Time Clock RTC, ou a busca da hora na internet. Esse número irá sofrer overflow (chegar ao maior número possível e então voltar pra zero), após aproximadamente 50 dias.

 Sintaxe:
tempo = cronometro();

 Ex.:
  // Declara uma variável chamada tempo
  numeroLongo tempo = 0;
  configuracao() {
   // Inicia a cominicação serial
   USB.conectar(9600);
  }
  principal() {
   // Envia a varíavel tempo pelo serial
   tempo = cronometro();
   USB.enviarln(tempo);
   // Espera um segundo
   esperar(1000);
  }

 Usado para atribuir um nome a uma variável constante. Quando o código é compilado todas as ocorrências do <nome> são substituídas pelo <valor>, seja ele um valor valor numérico ou uma palavra ou letra.

 Sintaxe:
  definir NomeConstante valor;

 Ex.:
  definir LED 3
  \\O compilador substituira qualquer menção do LED pelo valor 3 no tempo de compilação.
  configuracao() {
   definirModo(LED, SAIDA);
  }
  principal() {
   ligar(LED);
   esperar(1000);
   desligar(LED);
   esperar(1000);
  }

 Obs.: Erro comum: “definir LED 3;”. Esse comando não precisa de ‘;’ no final dele.

 Essa função manda o valor de um byte a um bit por vez. A ordem de mudança pode ser feita a partir do bit mais significativo ou a partir do menos significativo. Cada bit é enviado, um de cada vez, para um pino de dados.

 Ex.:
  enviarBinario(dataPin, clockPin, Direto, valor);

 Pausa o programa por um determinado período de tempo definido em milissegundo (ms). Após a espera ele continua o código normalmente.

 Sintaxe:
esperar (milissegundos);

 Ex.:
  // O código pausa o programa por um segundo antes de alternar o pino de saída.
  numero LED = 13; // LED conectado no pino digital 13

  configuracao() {
   definirModo(LED, SAIDA); // define o pino LED como saida
  }
  principal() {
   // Liga o LED
   ligar(LED);
   // espera 1 segundo
   esperar(1000);
   // Desliga o LED
   desligar(LED);
   // espera 1 segundo
   esperar(1000);
  }

 Converte uma Palavra válida em um número inteiro. Para isso a Palavra tem que obrigatoriamente começar com um número. Caso a Palavra não seja válida o retorno será 0.

 Sintaxe:
minhaPalavra.emNumero();

 Ex.:
  configuracao() {
   USB.conectar(9600); // Inicia uma comunicação serial
  }
  principal() {
   // Inicia uma variável com a Palavra 123456
   Palavra minhaPalavra = "123456";
   // Conver´te a palavra para número, subtrai 3 e envia a palavra para o monitor serial
   USB.enviarln(minhaPalavra.emNumero()-3);
  }

 Comando para o controle do buzzer, caso a porta não esteja “soando” a operação não tem efeito. Necessita de um parâmetro que indica a porta na qual o buzzer está conectado.

 Ex.:
  numero buzzer = 9;
  configuracao(){}
  principal() {
   soar(buzzer, 440);
   esperar(500);
   pararSoar(buzzer);
   esperar(1000);
  }

 Essa função realiza uma operação similar a uma regra de três. Ela realoca um valor de um intervalo dado em proporção a outro intervalo.

 Ex.:
  configuracao() {}
  principal() {
   numero val = lerAnalogico(A0);
   val = proporcionar(val, 0, 1023, 0, 255);
   escreverAnalogico(9, val);
   esperar(30);
  }

 Modifica uma Palavra em local, removendo caracteres do endereço dado até o fim da Palavra, ou até o endereço resultante da soma do valor do primeiro endereço com um valor específico(também fornecido pelo usuário).

 Ex.:
  //X variavel positiva e inteira
  remover(X);
  //X e Y variaveis inteiras e positivas
  remover(X , Y);

 Possui dois parâmetros, o primeiro é a porta e o segundo a frequência que ela deve tocar. A função também aceita um terceira argumento que determina a duração desejada em milésimos de segundo. O Arduino de modo geral aceita frequências entre 31 Hz e 65535 Hz.

 Sintaxe:
  soar(pino, frequencia);
  soar(pino, frequencia, duracao);

  pino - o pino o qual gera o soar;
  frequencia - a frequência do tom em hertz - Modulo numero;
  duracao - a duração do tom em milissegundos (opcional) - Modulo numeroLongo;

 Ex.:
  numero buzzer = 9;
  configuracao(){}
  principal() {
   soar(buzzer, 440);
   esperar(500);
   pararSoar(buzzer);
   esperar(1000);
  }

 Retorna o comprimento (número de caracteres) de uma palavra. Necessita de um parâmetro que é a palavra que será medida.

 Ex.:
  Palavra[] nome=”Brino”;

  configuracao() {
   USB.conectar(9600);
   USB.enviar(“Comprimento da Palavra: ”);
   USB.enviarln(nome.tamanho());
   // Nao se esqueca que as palavras possuem um caractere invisivel no final.
  }
  principal() {}

 Compara se uma Palavra termina com outra Palavra com retorno booleano de 1 ou 0

 Sintaxe:
minhaPalavra.terminaCom(comparacao);

 Ex.:
  configuracao() {
   USB.conectar(9600); // Inicia uma comunicação serial
  }
  principal() {
   // Inicia uma variável com a Palavra minhaPalavra com valor 123456
   Palavra minhaPalavra = "123456";
   // Inicia uma variável com a Palavra comparacao com valor 123
   Palavra comparacao = "123";
   // Verifica se a minhaPalavra termina com 123
   USB.enviarln(minhaPalavra.terminaCom(comparacao));
   // Retorna 0 no monitor serial
  }

 É responsável por preparar o hardware para a execução do loop principal. O método de configuracao() é executado uma única vez quando o Arduino é ligado ou resetado e é ignorado no decorrer do restando do código. É nele que definimos a conexão com a porta USB, os modos de operação dos pinos, e outros parâmetros que necessitam ser executados apenas uma vez.
 
 Ex.:
  configuracao() {
   definirModo(13, SAIDA);
  }

  principal() {
   ligar(13);
   esperar(1000);
   desligar(13);
   esperar(1000);
  }

 O método principal() é um dos mais usados para se colocar a parte principal do programa. Ele é executado a partir do momento que o Arduino é ligado, após a execução da configuração, até o momento em que ele é desligado podendo ser repetido incontáveis vezes. Nele colocamos todas as operações necessárias para o funcionamento contínuo do projeto.

 Ex.:
  numero pinoBotao = 3;

  // configuracao inicializa da serial e do pinoBotao
  configuracao() {
   USB.conectar(9600);
   definirModo(pinoBotao, ENTRADA);
  }

  // o laco checa o estado do pino
  // e manda para o monitor serial
  principal() {
   se (lerDigital(pinoBotao) == LIGADO)
    USB.escrever('L');
   senao
    USB.escrever('D');
   esperar(1000);
  }

 Essa biblioteca permite comunicações com comunicação I2C/TWI.

 Ex.:
  usar I2C

  configuracao() {
   I2C.conectar();
  }

  byte val = 0;

  principal() {
   I2C.transmitir(44);
   I2C.escrever(byte(0x00));
   I2C.escrever(val);
   I2C.pararTransmitir();

   val++;

   se(val == 64) {
    val = 0;
   }

   delay(500);
  }

 Inicia a biblioteca Wire e junta-se ao I2C bus como mestre ou escravo. Isso deverá ser chamado apenas uma vez.

 Ex.:
   I2C.conectar();

 Retorna o número de bytes disponíveis para recuperação com ler(). Isso deve ser chamado em um dispositivo mestre após uma chamada para solicitar() ou em um escravo dentro do manipulador recebido().

 Ex.:
  I2C.disponivel();

 Grava dados de um dispositivo escravo em resposta a uma solicitação de um mestre, ou bytes de filas para transmissão de um dispositivo mestre para escravo (chamadas intermediárias para transmitir() e pararTransmitir()).

 Ex.:
  I2C.escrever(valor);
  I2C.escrever(palavra);

 Lê um byte que foi transmitido de um dispositivo escravo para um mestre depois de uma chamada para solicitar() ou foi transmitido de um mestre para um escravo.

 Ex.:
  I2C.ler();

 Essa função para a transmissão de um aparelho escravo que fora começada pela função transmitir() e envia os bytes “da fila”.

 Ex.:
  I2C.pararTransmitir();

 Registra a função que deve ser chamada quando um aparelho escravo recebe uma transmissão do mestre (comunicação I2C).

 Ex.:
  I2C.recebido();

 Registra uma função que será chamada quando o mestre solicita dados do aparelho escravo.

 Ex.:
  I2C.solicitado();

 Função utilizada pelo mestre para solicitar bytes de um aparelho escravo.

 Ex.:
  I2C.solicitar();

 Inicia a transmissão com o aparelho escravo I2C do endereço dado. Essa função recebe como parâmetro o endereço composto pelos 7 bits do aparelho.

 Ex.:
  I2C.transmitir();

  Usado junto do comando "selecionar" indicando os casos em que serão comparados com o valor.

 Ex.:
  numero entrada = 2;

  configuracao() {
   USB.conectar(9600);
  }
  principal() {
   seletor (entrada) {
    caso 1:
     USB.enviarln("Primeiro caso");
     quebrar;
    caso 2:
     USB.enviarln("Segundo caso");
     quebrar;
    caso 3:
     USB.enviarln("Terceiro caso");
     quebrar;
   }
  }

 Esse laço de repetição executa um bloco enquanto a condição entre parênteses for verdadeira.

 Ex.:
  numero contador = 0;

  configuracao() {
   USB.conectar(9600);
  }
  principal() {
   // Conta de 0 a 19
   enquanto(contador < 20){
    USB.enviarln(vontador);
    contador++;
   }
  }

 Esse comando é usado junto ao "seletor" (switch). Quando uma entrada no seletor não se encaixa em nenhum dos casos descritos, a seleção escolhe a opção "padrao", caos ela esteja disponível. O uso dela no seletor é opcional. Sua estrutura começa com ela, dentro do seletor, abrindo um bloco com dois pontos (':') e o fechando com o comando "quebrar".
 Ex.:
  numero entrada = 2;

  configuracao() {
   USB.conectar(9600);
  }
  principal() {
   seletor (entrada) {
    caso 1:
     USB.enviarln("Primeiro caso");
     quebrar;
    caso 2:
     USB.enviarln("Segundo caso");
     quebrar;
    padrao:
     USB.enviarln("Caso 3, padrao");
     quebrar;
   }
  }

 Laço de repetição com 3 parâmetros. Inicio: Indica o valor inicial da variável do laço, condicao: Condição para a execução do método, Operacao: Operação que será realizada na variável para que ele percorra o laço.

 Ex.:
  numero pinoLED= 13;

  configuracao(){
   definirModo(pinoLED, SAIDA);
  }

  principal(){
   para (int t=100; t <= 1000; t=t+10){
    ligar(pinoLED);
    esperar(t);
    desligar(pinoLED);
    esperar(t);
   }
  }

  Incica o fim do bloco caso. Usado junto ao comando "seletor".

 Ex.:
  numero entrada = 2;

  configuracao() {
   USB.conectar(9600);
  }
  principal() {
   seletor (entrada) {
    caso 1:
     USB.enviarln("Primeiro caso");
     quebrar;
    caso 2:
     USB.enviarln("Segundo caso");
     quebrar;
    caso 3:
     USB.enviarln("Terceiro caso");
     quebrar;
   }
  }

 É uma condicional que verifica se a condição entre os parenteses é “Verdadeira” ou “Falsa”, se o resultado for “Verdadeiro” o bloco a seguir é executado, caso contrário ele será ignorado.

 Ex.:
  numero botao = 9;

  configuracao() {
   USB.conectar(9600);
   definirModo(botao, SAIDA);
  }
  principal() {
   se(lerDigital(botao) == LIGADO){
    USB.enviarln(“O botao foi acionado!”);
   }
   esperar(1000);
  }

 É usado após o bloco de um se() (if()). O bloco desta instrução é executado caso a condição da condicional anterior não tenha sido satisfeita, ou seja, caso o bloco se tenha sido ignorado.

 Ex.:
  numero botao = 9;

  configuracao() {
   USB.conectar(9600);
   definirModo(botao, SAIDA);
  }
  principal() {
   se(lerDigital(botao) == LIGADO){
    USB.enviarln(“O botao esta ligado!”);
   }
   senao{
    USB.enviarln(“O botao esta desligado”);
   }
   esperar(1000);
  }

  Similar o "se()" o seletor é capaz de atuar similar a um multiplexador, onde a partir e diferentes entradas ele pode selecionar uma das opções.

 Ex.:
  numero entrada = 2;

  configuracao() {
   USB.conectar(9600);
  }
  principal() {
   seletor (entrada) {
    caso 1:
     USB.enviarln("Primeiro caso");
     quebrar;
    caso 2:
     USB.enviarln("Segundo caso");
     quebrar;
    caso 3:
     USB.enviarln("Terceiro caso");
     quebrar;
   }
  }

 Especifica uma Rotina de Serviço de Interruptores(ISR, em inglês), já declarada, a avisa quando ocorre um interromper.

 Sintaxe:
  conectarInterruptor(porta, funcao, modo);

  porta- Variavel que indica a porta usada para a interrupção. No caso do Arduino UNO, 0 corresponde a porta digital 2 e 1 a porta digital 3
  funcao - função chamada quando quando ocorre a interrupção
  modo - Varivel que define o tipo de variação no sinal da porta deve ocorrer para a interrupção ocorrer (DESLIGADO, LIGANDO, DESLIGANDO ou MUDANDO)

 Ex.:
  conectarInterruptor();

 OBS.: Os comandos interruptores não funcionam em todas as portas do Arduino. Para saber quais pinos de sua placa estão disponíveis para o uso do comando acesse a documentação específica de sua placa. Nas placas Arduino Uno, Arduino Nano e Arduino Mini as portas são a D2 e D3, Já na placa Arduino Mega as portas que podem ser utilizadas para o comando são a D2, D3, D18, D19, D20 e D21.

 Desliga o interruptor. Essa função possui um parâmetro: o número do interruptor a ser desligado. Ela também não retorna nada. Vale ressaltar que, para o Arduino Due, essa função recebe o argumento que define o número do pino do interruptor a ser desligado.

 Sintaxe:
  desconectarInterruptor (interruptor);

  -interromper: o número da interrupção para desativar
  -pino: o número do pino da interrupção para desabilitar (apenas Arduino Due).

 Ex.:
  desconectarInterruptor();

 Esse comando desativa os interruptores (eles podem ser acionados pelo comando ligarInterruptores()). Interruptores permitem que tarefas específicas e importantes possam funcionar em plano de fundo e são ativadas por padrão. Algumas funções não serão executadas enquanto interruptores estão desativados, e informações que estão por vir podem ser ignoradas. Interruptores podem perturbar levemente o andamento do código, mas podem ser desativados para seções críticas do algoritmo.

 Ex.:
  principal(){
   desligarInterruptores();
   // Codigo que não pode ser interrompido
   ligarInterruptores();
   // Resto do codigo
  }

 Esse comando aciona os interruptores (após serem desativados pelo comando desligarInterruptores()). Interruptores permitem que tarefas específicas e importantes possam funcionar em plano de fundo e são ativadas por padrão. Algumas funções não serão executadas enquanto interruptores estão desativados, e informações que estão por vir podem ser ignoradas. Interruptores podem perturbar levemente o andamento do código, mas podem ser desativados para seções críticas do algoritmo.

 Ex.:
  principal(){
   desligarInterruptores();
   // Codigo que não pode ser interrompido
   ligarInterruptores();
   // Resto do codigo
  }

 Constante válida para um dos argumentos da função conectarInterruptor(). É utilizada para acionar o interruptor sempre que o estado do pino mude de valor.

 Ex.:
  conectarInterruptor(digitalPinToInterrupt(BOTAO), ISR, MUDANDO);

 Ativa a função de rolagem automática do LCD. Esse efeito faz com que cada novo caracter escrito no display ocupe o lugar do anterior e "empurre" todos os outros já no display uma posição para o lado. No caso da direção do texto estar da esquerda para a direita (padrão) a rolagem será para a esquerda, caso a direção do texto seja a oposta a rolagem será para a direita. Seu funciona é oposto ao do pararAutoRolar()

 Sintaxe:
  lcd.autoRolar();

  -lcd = Nome do LCD conectado.

 Ex.:
  // Chama a biblioteca LCD para ser usada
  usar LCD

   // Cria um objeto do tipo LCD com o nome lcd conectado as portas declaradas entre parenteses
  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   // Declara o tamanho da tela do LCD, isso eh, quantos caracteres cabem nele
   lcd.conectar(16,2);
   // Imprime "Ola mundo"
   lcd.enviar("ola, mundo!");
   // Espera um segundo
   esperar(1000);
   // Comeca o auto rolar do LCD
   lcd.autoRolar();
   lcd.enviar("teste");
  }

  principal() {}

 Cria uma variável do tipo LCD. A exibição na tela pode ser controlada usando 4 ou 8 pinos de dados.

 Sintaxe:
  LCD (NP, E, d4, d5, d6, d7)

  -NP = numero do pino do arduino.
  -E = o numero do pino de controle do LCD.
  -d4, d5, d6, d7 = os números dos pinos Arduino que estão conectados aos pinos de dados correspondentes no LCD.

 Ex.:
  usar LCD

  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   lcd.conectar(16,1);
   lcd.enviar("ola, mundo!");
  }

  principal() {}

 Inicializa a interface na tela LCD e especifica as dimensões (largura e altura) da tela. conectar() precisa ser chamado antes de qualquer outro comando da biblioteca LCD.

 Sintaxe:
  lcd.conectar(numeroDeColunas, numeroDeLinhas);

 Ex.:
  usar LCD

  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   lcd.conectar(15,2);
   lcd.enviar("ola terraqueos!");
  }

  principal() {}

 Torna o cursor do display LCD visível.

 Sintaxe:
  lcd.cursor();

  -lcd = Nome do LCD conectado.

 Ex.:
  usar LCD

  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   lcd.conectar(16,1);
   lcd.enviar("ola, mundo!");
   esperar(1000);
   lcd.rolarMensagemDireita();
   // Esconde o cursor do LCD
   lcd.esconderCursor;
   esperar(1000);
   // Apresenta o cursor do LCD
   lcd.cursor;
   esperar(1000);
  }

  principal() {}

 Cria um caractere (grafo) customizado para ser utilizado no LCD. É possível cusmotizar até 8 caracteres com 5x8 pixels. A aparência de cada caractere customizado é feito em uma lista de 8 bytes. Para mostrar um pixel customizado basta utilizar a função .escrever() passando o index do byte de seu caractere.
Quando se tenta referenciar o caractere "0", se não for uma variável, você necessita fazê-lo como byte, se não o compilador vai apontar um erro.
 Sintaxe:
  lcd.criarLetra(<indexDaLetra>, <caractereCriado>);

  -lcd = Nome do LCD conectado.

 Ex.:
  // Chama a biblioteca LCD para ser usada
  usar LCD

   // Cria um objeto do tipo LCD com o nome lcd conectado as portas declaradas entre parenteses
  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  byte sorriso[8] = {
   B00000,
   B10001,
   B00000,
   B00000,
   B10001,
   B01110,
   B00000,
  };

  configuracao(){
   // Declara o tamanho da tela do LCD, isso eh, quantos caracteres cabem nele
   lcd.conectar(16,2);
   // Cria o caractere sorriso no index 0
   lcd.criarLetra(0, sorriso);
   // escreve o caractere do index 0 (sorriso) na tela
   lcd.escrever(byte(0));
  }

  principal() {}

  Define a direção do texto escrito no LCD da direita para a esquerda. Isso quer dizer que cada novo caractere a ser escrito no display vai da esquerda para a direita, mas não afeta o texto anterior.

 Sintaxe:
  lcd.direitaPraEsquerda();

  -lcd = Nome do LCD conectado.

 Ex.:
  // Chama a biblioteca LCD para ser usada
  usar LCD

   // Cria um objeto do tipo LCD com o nome lcd conectado as portas declaradas entre parenteses
  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   // Declara o tamanho da tela do LCD, isso eh, quantos caracteres cabem nele
   lcd.conectar(16,2);
   // Começa a escrever o texto da direita para a esquerda
   lcd.direitaPraEsquerda();
   // Imprime "Ola mundo"
   lcd.enviar("ola, mundo!");
  }

  principal() {}

 Imprime texto no LCD.

 Ex.:
  usar LCD

  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   lcd.enviar("ola!");
  }

  principal() {}

 Esconde o cursor do display LCD.

 Sintaxe:
  lcd.esonderCursor();

  -lcd = Nome do LCD conectado.

 Ex.:
  usar LCD

  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   lcd.conectar(16,1);
   lcd.enviar("ola, mundo!");
   esperar(1000);
   lcd.rolarMensagemDireita();
   // Esconde o cursor do LCD
   lcd.esconderCursor;
   esperar(1000);
   // Apresenta o cursor do LCD
   lcd.cursor;
   esperar(1000);
  }

  principal() {}

 Escreve um caracter no LCD.

 Ex.:
  usar LCD

  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   USB.conectar(9600);
  }

  principal(){
   se (USB.disponivel()) {
    lcd.escrever(USB.ler());
   }
  }

  Define a direção do texto escrito no LCD da esquerda para a direita, que é o padrão. Isso quer dizer que cada novo caractere a ser escrito no display vai da direita para a esquerda, mas não afeta o texto anterior.

 Sintaxe:
  lcd.esquerdaPraDireita();

  -lcd = Nome do LCD conectado.

 Ex.:
  // Chama a biblioteca LCD para ser usada
  usar LCD

   // Cria um objeto do tipo LCD com o nome lcd conectado as portas declaradas entre parenteses
  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   // Declara o tamanho da tela do LCD, isso eh, quantos caracteres cabem nele
   lcd.conectar(16,2);
   // Começa a escrever o texto da esquerda para a direita
   lcd.esquerdaPraDireita();
   // Imprime "Ola mundo"
   lcd.enviar("ola, mundo!");
  }

  principal() {}

 Apaga o que está escrito no LCD.

 Sintaxe:
  lcd.limpar();

  -lcd = Nome do LCD conectado.

 Ex.:
  usar LCD

  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   lcd.conectar(16,1);
   lcd.enviar("ola, mundo!");
   esperar(1000);
   lcd.limpar();
  }

  principal() {}

 Posiciona o cursor no canto superior esquedo do LCD. Ou seja, utiliza essa posição para imprimir os próximos textos a serem inseridos no dispolay. Para também limpar o conteúdo da tela é necessário utilizar a função "limpar()".

 Sintaxe:
  lcd.origem();

  -lcd = Nome do LCD conectado.

 Ex.:
  // Chama a biblioteca LCD para ser usada
  usar LCD

   // Cria um objeto do tipo LCD com o nome lcd conectado as portas declaradas entre parenteses
  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   // Declara o tamanho da tela do LCD, isso eh, quantos caracteres cabem nele
   lcd.conectar(16,2);
   // Imprime "Ola mundo"
   lcd.enviar("ola, mundo!");
   // Espera um segundo
   esperar(1000);
   // Limpa o conteudo da tela
   lcd.limpar();
   // Volta para o canto superior esquerdo(origem)
   lcd.origem();
   // Imprime "Outra mensagem!"
   lcd.enviar("Outra mensagem!");
   // Apresenta o cursor do LCD
  }

  principal() {}

 Desativa a função de rolagem automática do LCD. Esse efeito faz com que cada novo caracter escrito seja apresentado ao lado do anterior. Seu funcionamento é o oposto ao do autoRolar()

 Sintaxe:
  lcd.pararAutoRolar();

  -lcd = Nome do LCD conectado.

 Ex.:
  // Chama a biblioteca LCD para ser usada
  usar LCD

   // Cria um objeto do tipo LCD com o nome lcd conectado as portas declaradas entre parenteses
  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   // Declara o tamanho da tela do LCD, isso eh, quantos caracteres cabem nele
   lcd.conectar(16,2);
   // Imprime "Ola mundo"
   lcd.enviar("ola, mundo!");
   // Espera um segundo
   esperar(1000);
   // Comeca o auto rolar do LCD
   lcd.autoRolar();
   lcd.enviar("teste");
   esperar(1000);
   // Para o auto rolar do LCD
   lcd.pararAutoRolar();
   lcd.enviar("Ola");
  }

  principal() {}

 Para de mostrar o cursor piscando no LCD. Funciona de maneira oposta ao piscarCursor().

 Sintaxe:
  lcd.pararPiscarCursor();

  -lcd = Nome do LCD conectado.

 Ex.:
  // Chama a biblioteca LCD para ser usada
  usar LCD

   // Cria um objeto do tipo LCD com o nome lcd conectado as portas declaradas entre parenteses
  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   // Declara o tamanho da tela do LCD, isso eh, quantos caracteres cabem nele
   lcd.conectar(16,2);
   // Imprime "Ola mundo"
   lcd.enviar("ola, mundo!");
   // Espera um segundo
   esperar(1000);
   // Comeca a piscar o cursor
   lcd.PiscarCursor();
   esperar(5000);
   // Para de piscar o cursor
   lcd.pararPiscarCursor();
  }

  principal() {}

 Mostra um cursor piscando no LCD. Se utilizado com a função cursor() o resultado irá depender do LCD específico utilizado. Funciona de maneira oposta ao pararPiscarCursor().

 Sintaxe:
  lcd.piscarCursor();

  -lcd = Nome do LCD conectado.

 Ex.:
  // Chama a biblioteca LCD para ser usada
  usar LCD

   // Cria um objeto do tipo LCD com o nome lcd conectado as portas declaradas entre parenteses
  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   // Declara o tamanho da tela do LCD, isso eh, quantos caracteres cabem nele
   lcd.conectar(16,2);
   // Imprime "Ola mundo"
   lcd.enviar("ola, mundo!");
   // Espera um segundo
   esperar(1000);
   // Comeca a piscar o cursor
   lcd.piscarCursor();
  }

  principal() {}

 É um comando utilizado pela biblioteca do LCD, ele serve para definir a posição do cursor utilizando dois parâmetros, como em um plano cartesiano, x horizontal (Linhas) e y vertical (Colunas).

 Ex.:
  lcd.posicao (0 , 0); //topo esquerda
  lcd.posicao (15 , 0); //topo direita
  lcd.posicao (0 , 1); //inferior esquerda
  lcd.posicao (15 , 1);//inferior direita

 Movimenta o conteudo do display e o cursor uma casa para a direita.

 Sintaxe:
  lcd.rolarMensagemDireita();

  -lcd = Nome do LCD conectado.

 Ex.:
  // Chama a biblioteca LCD para ser usada
  usar LCD

   // Cria um objeto do tipo LCD com o nome lcd conectado as portas declaradas entre parenteses
  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   // Declara o tamanho da tela do LCD, isso eh, quantos caracteres cabem nele
   lcd.conectar(16,1);
   // Imprime "Ola mundo"
   lcd.enviar("ola, mundo!");
   // Espera um segundo
   esperar(1000);
   // Rola a mensagem da tela
   lcd.rolarMensagemDireita();
  }

  principal() {}

 Movimenta o conteudo do display e o cursor uma casa para a esquerda.

 Sintaxe:
  lcd.rolarMensagemEsquerda();

  -lcd = Nome do LCD conectado.

 Ex.:
  usar LCD

  LCD lcd(12, 11, 10, 5, 4, 3, 2);

  configuracao(){
   lcd.conectar(16,1);
   lcd.enviar("ola, mundo!");
   esperar(1000);
   lcd.rolarMensagemEsquerda();
  }

  principal() {}

 Memória de 512 bytes da placa que é capaz de guardar dados mesmo após a placa ser desligada. A função escrever é usada para guardar dados nesta memória.

 Ex.:
  configuracao() {
   para( numero x = 0; x < 5; x++){
    numero d = lerAnalogico(0);
    Memoria.escrever(x, d);
    USB.enviarln(d);
   }
  }
  principal() {}

 Essa função apaga todos os valores gravados na memória EEPROM.

 Ex.:
  formatar();

 Lê um byte da EEPROM. EEPROM é uma memória onde dados podem ser armazenados para serem salvos mesmo ao desligar o Arduino.

 Ex.:
  // Chama a biblioteca Memoria para ser usada
  usar Memoria

   // Cria duas variáveis e inicializa elas
  numero leitura = 0;
  numero valor = 0;

  configuracao() {
   // Inicia a comunicação serial
   USB.conectar(9600);
  }

  principal() {
   // Realiza uma leitura de memoria e armazena o dado na variável Valor
   Valor = Memoria.ler(leitura);
   // Envia a variável leitura pela porta serial
   USB.enviar(leitura);
   // Faz uma tabulação
   USB.enviar("\t");
   // Envia a variável valor pela porta serial
   USB.enviarln(valor);
   // Soma 1 à variável leitura
   leitura = leitura + 1;
   // Verifica se o valor da variável é igual a 512
   se (leitura == 512){
    // Reinicia a variável leitura
    leitura = 0;
   }
   // Espera meio segundo
   esperar(500);
  }

 Retorna o tamanho da memória do arduino usado.

 Ex.:
  enquanto (x < Memoria.tamanho()){}

 Esse comando é usado junto a declaração de uma variável tornando-a constante, ou seja, o valor dela não poderá ser mudado posteriormente.

 Ex.:
  Constante numeroDecimal PI = 3.14;
  numeroDecimal Raio = 10;

  configuracao() {
   USB.conectar(9600);
   USB.enviar(“comprimento da circunferencia: ”);
   USB.enviarln(2*PI*Raio);
  }
  principal() {}

 Obs.: PI = 7; // Nao permitido, voce nao podera mudar a constante ao longo do codigo.
 Obs2.: definir ou Constante
  Você pode usar Constante ou definir para criar constantes numéricas ou de palavras. Para vetores, você precisará usar Constante. Em geral, Constante é preferido sobre definir para declarar constantes.

 Utilizado para retirar a capacidade de uma variável de armazenar valores negativos, para assim aumentar o seu valor máximo. Utiliza dois parâmetros, o tipo de variável e respectivamente a variável que se deseja atribuir o comando.

 Sintaxe:
  Modulo TipoDeVariável Nome = Valor;
  TipoDeVariável = de que tipo é sua variável, numero, numeroDecimal, etc.
  Nome = o nome da sua variável TipoDeVariável;
  Valor = o valor associado ao nome.

 Ex.:
  Modulo numero X;

 Ex2.:
  Modulo letra X = 240;

 Ex3.:
  Modulo numeroLongo X = 1000250;

 Obs.: Por que usar o Modulo? Além de aumentar o valor positivo que você poderá usar , o Modulo permite que aconteça o comportamento de rolagem.

 Define a velocidade de um determinado motor de passo. Velocidades muito altas farão ele travar. OBS: Esse comando não faz o motor se mover, para isso use a função "passo()".

 Ex.:
  // Chama a biblioteca MotorDePasso para ser usada
  usar MotorDePasso
  // Cria o objeto "motor" passando 5 parâmetros: o primeiro é a quantidade de passos para realizar uma rotação completa e os outros 4 definem as portas que o motor está conectado.
  MotorDePasso motor(512, 8,10,9,11);

  configuracao() {
   // Definea velocidade do motor em 60
   motor.definirVelocidade(60)
   USB.enviar(“Oi!”);
  }
  principal() {}
   // Dá 5 passos
   motor.passo(5)
  }

 Chama a biblioteca "Stepper" para ser utilizada e controlar motores de passo com mais facilitade.

 Ex.:
  // Chama a biblioteca MotorDePasso para ser usada
  usar MotorDePasso

 Utilizado para que um motor específico dê uma quantidade determinada de "passos". Cada passo é uma rotação completa do motor

 Ex.:
  // Chama a biblioteca MotorDePasso para ser usada
  usar MotorDePasso
  // Cria o objeto "motor" passando 5 parâmetros: o primeiro é a quantidade de passos para realizar uma rotação completa e os outros 4 definem as portas que o motor está conectado.
  MotorDePasso motor(512, 8,10,9,11);

  configuracao() {
   // Definea velocidade do motor em 60
   motor.definirVelocidade(60)
   USB.enviar(“Oi!”);
  }
  principal() {}
   // Dá 5 passos
   motor.passo(5)
  }

 Esse operador é utilizado para somar dois valores ou variáveis.

 Ex.:
  2 + 3 ;

 Ex2.:
  x + y;

 Esse operador é utilizado para diminuir um valor de outro ou uma variável de outra.

 Ex.:
  5 - 3;

 Ex2.:
  x - y;

 Esse operador é utilizado para multiplicar dois valores ou variáveis.

 Ex.:
  2 * 7;

 Ex2.:
  x * y;

 Esse operador é utilizado para dividir dois valores ou variáveis.

 Ex.:
  9 / 7;

 Ex2.:
  x / y;

 Esse comando é usado para fazer um comentário no código, ou seja, um trecho de código que serve como anotação e é ignorado pelo Arduino.

 Ex.:
  // Isso e um exemplo de comentario de uma unica linha

Ex2.:
  /* Isso e
   um comentario
  que pode ter
  varias linhas */

- Estado desligado, sem voltagem.

 Ex.:
  numero pino = 7;
  Modulo numeroLongo duracao;

  configuracao(){
   definirModo(pino, ENTRADA);
   USB.conectar(9600);
  }

  principal() {
   duracao = pulsoEm(pino, DESLIGADO);
   USB.enviarln(duracao);
   esperar(1000);
  }

- Usada junto ao conjunto de instruções do interruptor para quando o Pino sai do estado LIGADO para DESLIGADO.

 Ex.:
  conectarInterruptor(7, ISR, DESLIGANDO);

- Essa constante é argumento da função enviarBinario e define que a ordem de envio dos bits a partir do Bit Menos Significativo, ou seja, o bit mais à direita do byte.

 Ex.:
  numero latPin = 8;
  numero cloPin = 12;
  numero dataPin = 11;

  configuracao() {
   definirModo(latPin, SAIDA);
   definirModo(cloPin, SAIDA);
   definirModo(dataPin, SAIDA);
  }
  principal() {
   para (int j = 0; j < 256; j++) {
    escreverDigital(latPin, DESLIGADO);
    enviarbinario(dataPin, clockPin, DIREITO, j);
    escreverDigital(latPin, LIGADO);
    esperar(1000);
   }
  }

- Parâmetro que indica entrada, que recebe energia do meio externo. Usado junto ao comando definirModo().

 Ex.:
  numero pinoLED = 13;
  numero botao = 7;

  configuracao() {
   definirModo(pinoLED, SAIDA);
   definirModo(botao, ENTRADA);
  }
  principal() {
   se(lerDigital(botao) == LIGADO){
    ligar(pinoLED);
    esperar(1000);
   }
   desligar(pinoLED);
  }

- Parâmetro que indica entrada, que recebe energia do meio externo, acionando o resistor pullup interno de sua placa. Isso funciona como um filtro evitando leituras equivocadas.

 Ex.:
  numero pinoLED = 13;
  numero botao = 7;

  configuracao() {
   definirModo(pinoLED, SAIDA);
   definirModo(botao, ENTRADA_PULLUP);
  }
  principal() {
   se(lerDigital(botao) == LIGADO){
    ligar(pinoLED);
    esperar(1000);
   }
   desligar(pinoLED);
  }

- Parâmetro que indica entrada, que recebe energia do meio externo, acionando o resistor pulldown interno de sua placa. Isso funciona como um filtro evitando leituras equivocadas.

 Ex.:
  numero pinoLED = 13;
  numero botao = 7;

  configuracao() {
   definirModo(pinoLED, SAIDA);
   definirModo(botao, ENTRADA_PULLDOWN);
  }
  principal() {
   se(lerDigital(botao) == DESLIGADO){
    ligar(pinoLED);
    esperar(1000);
   }
   desligar(pinoLED);
  }

- Essa constante é argumento da função enviarBinario e define que a ordem de envio dos bits a partir do Bit Mais Significativo, ou seja, o bit mais à esquerda do byte.

 Ex.:
  numero laitPin = 8;
  numero cloPin = 12;
  numero dataPin = 11;

  configuracao() {
   definirModo(latPin, SAIDA);
   definirModo(cloPin, SAIDA);
   definirModo(dataPin, SAIDA);
  }

  principal() {
   para (int j = 0; j < 256; j++) {
    escreverDigital(laitPin, DESLIGADO);
    enviarbinario(dataPin, clockPin, ESQUERDO, j);
    escreverDigital(laitPin, LIGADO);
    esperar(3000);
   }

 Condição booleana de falso, 0.

 Ex.:
  numero botao = 9;

  configuracao() {
   definirModo(botao, SAIDA);
   USB.conectar(9600);
  }
  principal() {
   se((lerDigital(botao)==DESLIGADO) == Falso){
    USB.enviarln(“ligado”);
    esperar(500);
   }
  }

- Parâmetro de estado, LIGADO. Informa que há voltagem.

 Ex.:
  numero pino = 7;
  Modulo numeroLongo duracao;

  configuracao() {
   definirModo(pino, ENTRADA);
   USB.conectar(9600);
  }

  principal() {
   duracao = pulsoEm(pino, LIGADO);
   USB.enviarln(duracao);
   esperar(1000);
  }

- Usada junto ao conjunto de instruções do interruptor para quando o Pino sai do estado DESLIGADO para LIGADO.

 Ex.:
  conectarInterruptor(13, ISR, LIGANDO);

 Comando utilizado para adicionar uma biblioteca ao código. Necessita de um parâmetro, que é nome da variável a ser acrescentada ao programa.

 Ex.:
  usar Servo

  Servo meuServo;

  configuracao() {
   meuServo.conectar(digital.5);
  }
  principal() {
   meuServo.escreverAngulo(180);
   esperar(1000);
   meuServo.escreverAngulo(0);
   esperar(1000);
  }

 Finaliza a função em que este comando está inserido e retorna um dado para a função que a chamou.

 Ex.:
responder 0;

- Parâmetro que indica Saída, que emite energia. Usado junto ao definirModo();

 Ex.:
 numero pinoLED = 13;

  configuracao() {
   definirModo(pinoLED, SAIDA);
  }
  principal() {
   ligar(pinoLED);
   esperar(1000);
   desligar(pinoLED);
   esperar(1000);
  }

 Definido como uma variável com valor não nulo, geralmente representado pelo número 1.

 Ex.:
  numero botao = 9;

  configuracao() {
   definirModo(botao, SAIDA);
   USB.conectar(9600);
  }
  principal() {
   se((lerDigital(botao)==LIGADO) == VERDADEIRO){
    USB.enviarln(“ligado”);
    esperar(500);
   }
  }

 São os pinos com o nome ANALOG IN.Possuem uma letra ‘A’ na frente de cada número. Esses pinos são usados para leitura de sinais analógicos de sensores conectados ao Arduino, e podem ser de quaisquer valores entre 0 a 5 volts. Os pinos analógicos não precisam ser previamente configurados com a função definirModo( ) vez que esses atuam exclusivamente como entradas.

 São os pinos marcados com o nome “DIGITAL” ou um ‘D’ logo abaixo. Podem ser configurados pela função definirModo() para detectarem ou transmitirem níveis lógicos digitais (Verdadeiro/Falso, 1/0 ou LIGADO/DESLIGADO).

)  Configura uma porta como uma ENTRADA ou SAIDA de dados. Além disso, é possível ativar o resistor pullup e definir, assim, uma ENTRADA_PULLUP. Vale ressaltar que, ao definir uma ENTRADA, o Arduino automaticamente desativará os resistores pullup.

 Sintaxe:

  definirModo(pino, modo);

  -pino: o número do pino cujo modo você deseja configurar
  -modo: ENTRADA, SAIDA ou ENTRADA_PULLUP.


 Ex.:
  configuracao() {
   definirModo(13, SAIDA);
  }

  principal() {
   ligar(13);
   esperar(1000);
   desligar(13);
   esperar(1000);
  }

 Configura o estado da porta indicada para DESLIGADO. Essa função recebe um parâmetro, o número da porta a ser desligada.

 Ex.:
  configuracao() {
   definirModo(13, SAIDA);
  }

  principal() {
   ligar(13);
   esperar(1000);
   desligar(13);
   esperar(1000);
  }

 Grava um valor digital em um pino, ligando-o ou desligando-o. Pode ser usado para acender ou apagar um LED.

 Sintaxe:

  escreverDigital(pino, valor);

  -pino: o número do pino
  -valor: LIGADO ou DESLIGADO

 Ex.:
  configuracao() {
   definirModo(13, SAIDA);
  }

  principal() {
   escreverDigital(13, LIGADO);
   esperar(3000);
   escreverDigital(13, DESLIGADO);
   esperar(3000);
  }

 Grava um valor analógico (onda PWM) em um pino. Pode ser usado para acender um LED em diferentes intensidades ou para variar a velocidade de motores.

 Sintaxe:
  escreverAnalogico(pino, valor);

  pino: o pino para escrever. Tipos de dados permitidos: numero
  valor: numero inteiro entre 0 (sempre desligado) e 255 (sempre ligado)

 Ex.:
  numero PinoLED = 9;
  numero PinoAnalog = 0;
  numero valor = 0;

  configuracao() {
   definirModo(PinoLED, SAIDA);
  }

  principal() {
   valor = lerAnalogico(PinoAnalog);
   escreverAnalogico(PinoLED, valor / 4);
  }

 Faz a leitura do valor de uma porta determinada retornando LIGADO ou DESLIGADO.

 Ex.:
  numero LED = 13;
  numero Botao = 7;
  numero estado = 7;
  configuracao() {
   definirModo(LED, SAIDA);
   definirModo(Botao, ENTRADA);
  }

  principal() {
   estado = lerDigital(Botao);
   Escreve(LED, estado);
  }

 Faz a leitura do valor de uma porta analógica determinada retornando um valor inteiro entre 0 e 1023, referente a tensão de entrada.

 Ex.:
  numero LDR = 7;
  numero leitura = 0;
  configuracao() {
   USB.conectar(9600);
  }

  principal() {
   leitura = lerAnalogico(LDR);
   USB.enviarln(leitura);
   esperar(500);
  }

 Configura o estado da porta indicada para LIGADO. Essa função recebe um parâmetro, o número da porta a ser ligada.

 Ex.:
  numero LED = 13;
  configuracao() {
   definirModo(LED, SAIDA);
  }

  principal() {
   ligar(LED);
   esperar(3000);
   desligar(LED);
   esperar(3000);
  }

 Essa função lê um pulso(LIGADO ou DESLIGADO) em um pino. Por exemplo, se o parâmetro do seu pulsoEm() é LIGADO, a função irá aguardar o estado da porta ser LIGADO, quando isso ocorrer, iniciará a contagem do tempo e ,então, aguardará até que o estado do pino seja DESLIGADO, finalizando a contagem. A função retorna o comprimento o pulso em microssegundos. Vale ressaltar que esta função retorna 0 caso nenhum pulso ocorra dentro do intervalo estabelecido.

 Sintaxe:
  pulsoEm(pino, valor);
  pulsoEm(pino, valor, tempoLimite);

   -pino: o número do pino no qual você deseja ler o pulso. (numero)
   -valor: tipo de pulso a ler: LIGADO ou DESLIGADO.
   -tempoLimite (opcional): o número de microssegundos para aguardar o pulso para iniciar; O padrão é um segundo (Modulo numeroLongo).

 Ex.:
  numero pino = 7;
  Modulo numeroLongo duracao;

  configuracao() {
   definirModo(pino, ENTRADA);
   USB.conectar(9600);
  }

  principal() {
   duracao = pulsoEm(pino, LIGADO);
   USB.enviarln(duracao);
   esperar(1000);
   esperar(duracao);
  }

 São aquelas que, ao contrário das grandezas digitais, variam continuamente dentro de uma faixa de valores. O velocímetro de um carro, por exemplo, pode ser considerado analógico, pois o ponteiro gira continuamente conforme o automóvel acelera ou trava. Se o ponteiro girasse em saltos, o velocímetro seria considerado digital.(https://www.arduinoportugal.pt/grandezas-digitais-e-analogicas-e-pwm/)

 são aquelas que não variam continuamente no tempo, mas sim em saltos entre valores bem definidos. Um exemplo são os relógios digitais: apesar do tempo em si variar continuamente, o visor do relógio mostra o tempo em saltos de um em um segundo. Um relógio desse tipo nunca mostrará 12,5 segundos, pois, para ele, só existem 12 e 13 segundos. Qualquer valor intermediário não está definido. (https://www.arduinoportugal.pt/grandezas-digitais-e-analogicas-e-pwm/)

 Cria o objeto servo para ser utilizado.

 Ex.:
  usar Servo

  Servo meuServo;

  configuracao() {
   meuServo.conectar(digital.5);
  }
  principal() {
   meuServo.escreverAngulo(180);
   esperar(1000);
   meuServo.escreverAngulo(0);
   esperar(1000);
  }

 Esse comando é utilizado para o controle de servo motores. Ele necessita uma porta que indica em que porta digital o sinal do servo motor está conectado <nomeServo>.conectar(Digital.<porta>) Outra maneira de utilizar o comando inclui mais dois parâmetros <nomeServo>.conectar(Digital.<porta>, <val>). Onde <val> é o valor do sinal, que possui dois padrões: mínimo padrão (544) e o máximo padrão (2400).

 Sintaxe:
  servo.conectar(pin)
  servo.conectar(pin, min, max)

  -servo: uma variável de tipo Servo
  -pino: o número do pino no qual o servo está ligado
  -min (opcional): a largura do pulso, em microssegundos, correspondente ao ângulo mínimo (0 graus) no servo (padrão para 544)
  -max (opcional): a largura do pulso, em microssegundos, correspondente ao ângulo máximo (180 graus) no servo (padrão para 2400).

 Ex.:
  usar Servo

  Servo meuServo;

  configuracao() {
   meuServo.conectar(digital.5);
  }
  principal() {
   meuServo.escreverAngulo(180);
   esperar(1000);
   meuServo.escreverAngulo(0);
   esperar(1000);
  }

 Esse comando é utilizado para o controle de servo motores e possui a mesma funçao que o <nomeServo>.conectar seguindo uma sintaxe um pouco diferente. Ele necessita uma porta que indica em que porta digital o sinal do servo motor está conectado <nomeServo>.conectarServo(<porta>). Outra maneira de utilizar o comando inclui mais dois parâmetros <nomeServo>.conectarServo(<porta>, <val>). Onde <val> é o valor do sinal, que possui dois padrões: mínimo padrão (544) e o máximo padrão (2400).

 Sintaxe:
  servo.conectarServo(pin)
  servo.conectarServo(pin, min, max)

  -servo: uma variável de tipo Servo
  -pino: o número do pino no qual o servo está ligado
  -min (opcional): a largura do pulso, em microssegundos, correspondente ao ângulo mínimo (0 graus) no servo (padrão para 544)
  -max (opcional): a largura do pulso, em microssegundos, correspondente ao ângulo máximo (180 graus) no servo (padrão para 2400).

 Ex.:
  usar Servo

  Servo meuServo;

  configuracao() {
   meuServo.conectarServo(5);
  }
  principal() {
   meuServo.escreverAngulo(180);
   esperar(1000);
   meuServo.escreverAngulo(0);
   esperar(1000);
  }

 Envia um sinal ao Servo, controlando o eixo do motor de acordo com ele. Em servos de rotação limitada, esse valor representa o ângulo (em graus) da posição para que o eixo deve ir. Em servos de rotação contínua, esse parâmetro representa a velocidade de rotação, sendo 0 a velocidade máxima de um sentido de rotação, 90 o parâmetro de velocidade nula e 180 o valor máximo de velocidade no sentido oposto.

 Sintaxe:
  servo.escreverAngulo(angulo);

  -servo: uma variável de tipo Servo
  -ângulo: o valor a ser gravado no servo, de 0 a 180

 Ex.:
  usar Servo

  Servo meuServo;

  configuracao() {
   meuServo.conectar(digital.5);
  }
  principal() {
   meuServo.escreverAngulo(180);
   esperar(1000);
   meuServo.escreverAngulo(0);
   esperar(1000);
  }

 Envia um valor em microssegundos para o Servo Motor, controlando seu eixo de rotação de acordo com o sinal enviado. O parâmetro correto geralmente varia entre 1000 e 2000, sendo o primeiro a rotação completa no sentido horário e o segundo a rotação completa no sentido anti-horário. 1500 é o parâmetro que representa a metade do intervalo, e, logo, da rotação.
 Note que alguns fabricantes não seguem o intervalo padrão supracitado, mas normalmente seguem a regra de trabalhar com valores entre 700 e 2300. Busque encontrar os parâmetros limites de seu componente com cuidado, pois forçar o motor a rotacionar além do máximo permitido pelo eixo resulta em situações de alta corrente, que devem ser evitadas.
 Servos de rotação contínua respondem a esta função de forma análoga ao comando escreverAngulo().

 Sintaxe:

  servo.escreverMicros(uS);
  -servo: uma variável de tipo Servo
  -uS: o valor do parâmetro em microssegundos(numero).

 Ex.:
  usar Servo

  Servo MeuServo;

  Configuacao() {
   MeuServo.conectar(Digital.9);
   MeuServo.escreverMicros(1500);
  }

  principal() {}

 Constante para o controle do servo de rotação contínua que indica ao servo para rodar para frente. É equivalente à um numero com valor de 1700.

 Ex.:
  usar Servo

  Servo meuServo;

  configuracao() {
   meuServo.conectar(digital.5);
  }
  principal() {
   meuServo.escreverMicros(SERVOFRENTE);
   esperar(1000);
   meuServo.escreverMicros(SERVOPARAR);
   esperar(1000);
   meuServo.escreverMicros(SERVOTRAS);
   esperar(1000);
  }

 Constante para o controle do servo de rotação contínua que indica ao servo para parar de rodar. É equivalente à um numero com valor de 1500.

 Ex.:
  usar Servo

  Servo meuServo;

  configuracao() {
   meuServo.conectar(digital.5);
  }
  principal() {
   meuServo.escreverMicros(SERVOFRENTE);
   esperar(1000);
   meuServo.escreverMicros(SERVOPARAR);
   esperar(1000);
   meuServo.escreverMicros(SERVOTRAS);
   esperar(1000);
  }

 Constante para o controle do servo de rotação contínua que indica ao servo para rodar para trás. É equivalente à um numero com valor de 1300.

 Ex.:
  usar Servo

  Servo meuServo;

  configuracao() {
   meuServo.conectar(digital.5);
  }
  principal() {
   meuServo.escreverMicros(SERVOFRENTE);
   esperar(1000);
   meuServo.escreverMicros(SERVOPARAR);
   esperar(1000);
   meuServo.escreverMicros(SERVOTRAS);
   esperar(1000);
  }

 Cria uma variável que é usada para guardar apenas dois valores, Verdadeiro ou Falso, e é muito usada em operações lógicas e controle.

 Ex.:
  condicao chovendo = Verdadeiro;
  condicao sol = Falso

 As variáveis do tipo numero (deve ser escrito dessa forma para ser entendido pelo compilador, sem acento e com letra maiúscula.) são muito usadas pois são capazes de, como o próprio nome sugere, armazenar números inteiros entre -32.768 a 32.767, ou seja, um número de 16 bits.

 Sintaxe:
  numero var = valor
  numero - tipo de variável
  var - o nome da sua variável;
  valor - o valor associado ao nome;

 Ex.:
  numero pinoLED = 13;

  configuracao() {
   definirModo(pinoLED, SAIDA);
  }
  principal() {
   ligar(PinoLED);
   esperar(1000);
   desligar(PinoLED);
   esperar(1000);
  }

 Obs.: Quando as variáveis ​​numero excedem sua capacidade máxima ou mínima, elas transbordam, ou seja, o resultado é imprevisível, devendo ser evitado.

 Essa variável armazena um caractere ASCII (Tabela de conversão de caracteres para números, permitindo que o Arduino as armazene), ou seja, ela é capaz de armazenar qualquer caractere (a, A, 1, &, entre outros). Operações aritméticas podem ser aplicadas sobre esses dados, porém ela será executada com base na tabela ASCII. Seu dado deve vir entre aspas simples (‘ ‘).

 Ex.:
  letra minhaLetra = 'A';
  letra minhaLetra = 65; // ambas atribuições são equivalentes

 Esse tipo de variável é capaz de armazenar números de até 32 bits com um ponto decimal. A matemática com o numeroDecimal é muito mais lenta do que a matemática com numero, na realização de cálculos, por isso, a maioria dos programadores a evita.

 Sintaxe:
  numeroDecimal var = valor
  numeroDecimal - tipo de variável
  var - o nome da sua variável numeroDecimal;
  valor - o valor associado ao nome;

 Ex.:
  numeroDecimal divisao;
  numeroDecimal calibracaoSensor = 1.117;

  numero x;
  numero y;
  numeroDecimal z;

  x = 1;
  y = x / 2; // y contem 0, variáveis do tipo numeros sao incapazes de guardar casas decimais
  z = (numeroDecimal)x / 2.0; // z contem 0.5 (voce devera usar 2.0 , e nao 2);

 Obs.: Se estiver fazendo cálculos com o numeroDecimal, adicione um ponto decimal, caso contrário, ele será tratado como um numero.

 Variável utilizada para valores longos, de até 32 bits, podendo variar entre -2,147,483,648 e 2,147,483,647.

 Sintaxe:
  numeroLongo variav = val
  variav - o nome da sua variável numeroLongo;
  val - o valor associado ao nome.

 Ex.:
  numeroLongo Y = 1050690;

 Obs.: Se estiver fazendo matemática com números inteiros, pelo menos um dos números deve ser seguido por um L, forçando-o a ser longo.

 Ex2.:
  numeroLongo VelLuz = 186000L;

 Variável utilizada para valores muito longos, de até 64 bits.

 Ex.:
  numeroLongo numeroLongo Y = 9223372036854775807;

 Esse tipo especial de variável pode ser comparado a uma série de caracteres. Ela é usada para armazenar palavras e frases. Seu dado deve vir entre aspas duplas (“ ”).
 Sintaxe:
  Todas as seguintes são declarações válidas para Palavra:
  letra Palavra1[15];
  letra Palavra2[6] = {'b', 'r', 'i', 'n', 'o'};
  letra Palavra3[6] = {'b', 'r', 'i', 'n', 'o', '\0'};
  letra Palavra4[ ] = "brino";
  letra Palavra5[6] = "brino";
  letra Palavra6[15] = "brino";
 * Possibilidades de declarar Palavras:
  - Declare uma série de caracteres sem inicializar como no Palavra1;
  - Declare uma série de caracteres (com espaço para um caractere adicional) e o compilador adicionará o caractere nulo necessário, como em Palavra2;
  - Adicione explicitamente o caractere nulo, Palavra3;
  - Inicialize com uma Palavra constante entre aspas; o compilador dimensionará a matriz para ajustar a constante de Palavra e um caractere nulo de término, Palavra4;
  - Inicialize a matriz com um tamanho explícito e constante de Palavra, Palavra5;
  - Inicialize a matriz, deixando espaço extra para uma Palavra maior, Palavra6.

 Ex.:
  letra* minhasPalavras[] = {"Essa e a palavra 1", "Essa e a palavra 2", "Essa e a palavra 3", "Essa e a palavra 4", "Essa e a palavra 5","Essa e a palavra 6"};

  configuracao(){
   USB.conectar(9600);
  }

  principal(){
   para (numero i = 0; i < 6; i++){
    USB.enviarln(minhasPalavras[i]);
    esperar(500);
   }
  }

 É um tipo de função vazia, utilizado para funções que não se espera resposta.

 Ex.:
  configuracao() {
   USB.conectar(9600);
  }
  principal() {
   minhaFuncao();
   esperar(1000);
  }
  semRetorno minhaFuncao(){
   USB.enviarln(“oi”);
  }

 Configura a velocidade da comunicação Serial em bits por segundo (baud). Para comunicação com o computador o mais usado é 9600 e ele aceita valores como: 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800 e 38400. Para outras comunicações, como a com componentes com as portas digitais, velocidades específicas podem ser definidas. Esse comando ainda aceita um segundo comando de configuração (config) que define dados, paridade e bits de parada. Os valores do segundo parámetro podem ser: SERIAL_5N1, SERIAL_6N1, SERIAL_7N1, SERIAL_8N1 (padrão), SERIAL_5N2, SERIAL_6N2, SERIAL_7N2, SERIAL_8N2, SERIAL_5E1, SERIAL_6E1, SERIAL_7E1, SERIAL_8E1, SERIAL_5E2, SERIAL_6E2, SERIAL_7E2, SERIAL_8E2, SERIAL_5O1, SERIAL_6O1, SERIAL_7O1, SERIAL_8O1, SERIAL_5O2, SERIAL_6O2, SERIAL_7O2 e SERIAL_8O2.

 Ex.:
  configuracao() {
   USB.conectar(9600);
   USB.enviar(“Oi!”);
  }
  principal() {}

 Espera a transmissão serial acabar

 Ex.:
  USB.descarregar();

 Obtém o número de bytes (caracteres) disponíveis para leitura a partir da porta serial. Este é o dado que já é armazenado no buffer de recebimento em série (que contém 64 bytes).

 Ex.:
  numero ByteRecebido = 0;

  configuracao() {
   USB.conectar(9600);
  }

  principal() {
   se (USB.disponivel() > 0) {
    ByteRecebido = USB.ler();
    USB.enviar("Eu recebi: ");
    USB.enviarln(ByteRecebido, DEC);
   }
  }

 Usado para enviar algum dado pela porta Serial. Aceita um segundo argumento opcional que define o formato desejado. Ele pode ser: BIN, OCT, HEX ou DEC. Essa função também retorna o número de bytes escritos, podendo esse valor ser usado ou não. Vale a pena lembrar que para escrever um texto na tela ele deve estar entre aspas (“”).

 Sintaxe:
  USB.enviar(valor);
  USB.enviar(valor, formato);

  -valor: o valor a imprimir - qualquer tipo de dado;
  -formato: especifica a base de números (para tipos de dados integrados) ou o número de casas decimais;

 Ex.:
  configuracao() {
   USB.conectar(9600);
   USB.enviar(“Isso vai aparecer no Monitor Serial”);
  }
  principal() {}

 Usado para enviar dados pela porta Serial em forma binária, sendo esses enviados na forma de um byte ou de uma série de bytes. Essa função retorna o número de bytes escritos, podendo esse valor ser usado ou não.

 Sintaxe:
  USB.escrever(valor);
  USB.escrever(palavra);
  USB.escrever(palavra, comprimento);

  -valor: o valor a ser enviado;
  -palavra: palavra (string) ou sequencia de dados a ser enviado;
  -comprimento: o número de bytes da palavra a ser enviado;

 Ex.:
  configuracao() {
   USB.conectar(9600);
   USB.escrever(45); // envia um byte com valor 45 (0b101101)
   Numero enviados = USB.escrever("Ola"); // envia uma palavra "Ola e registra na variavel enviados a quantidade de bytes enviados
  }
  principal() {}

 Usado para enviar algum dado pela porta Serial e em seguida quebrar a linha. Aceita um segundo argumento opcional que define o formato desejado. Ele pode ser: BIN, OCT, HEX ou DEC. Essa função também retorna o número de bytes escritos, podendo esse valor ser usado ou não. Vale a pena lembrar que para escrever um texto na tela ele deve estar entre aspas (“ ”).

 Sintaxe:
  USB.enviar(valor);
  USB.enviar(valor, formato);

  valor: o valor a imprimir - qualquer tipo de dado;
  formato: especifica a base de números (para tipos de dados integrados) ou o número de casas decimais;

 Ex.:
  configuracao() {
   USB.conectar(9600);
   USB.enviarln(“Isso vai aparecer no Monitor Serial e em seguida quebrara a linhal”);
  }
  principal() {}

 Retorna um inteiro com um byte das informações acessíveis na comunicação Serial ou -1 caso não tenha dados disponíveis.

 Ex.:
  dados = USB.ler();

 Ex2.:
  numero dado = 0;
  configuracao() {
   USB.conectar(9600);
  }

  principal() {
   se (USB.disponivel() > 0) {
    // Le o dado recebido e armazena na variavel
    dado = USB.ler();
    // Mostrar dado recebido
    USB.enviar("Recebido: ");
    USB.enviarln(dado, DEC);
   }
  }