Nosso software é completamente traduzido para o português, com palavras-chave intuitivas que facilitam a compreensão da lógica de programação. Além disso, pode-se mesclar códigos em linguagem Arduino com as instruções em português. Tudo para tornar o processo de aprendizagem mais acessível e interessante!
Agregando à filosofia de que qualquer um pode aprender robótica, Br.ino disponibiliza um e-book totalmente grátis! Deixe de lado as dificuldades e comece agora! Aprenda Arduino de forma prática e simples!
Fazer o download
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 ou igual a.
Ex.:
enquanto(x<=10){
//...
}
Maior que.
Ex.:
se(x>y){
//...
}
Maior ou igual a.
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);
}
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;
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. Esse comando só precisa ser chamado uma vez em seu código.
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);
}
}
Indica 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)
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).
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.
// 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.
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.
Sintace:lcd.cursor();
-lcd = Nome do LCD conectado.
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.
lcd.criarLetra(<indexDaLetra>, <caractereCriado>);
-lcd = Nome do LCD conectado.
// 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.
// 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.
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.
// 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.
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.
// 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.
// 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.
// 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.
// 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.
// 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.
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.
Obs. 2: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.
Modulo numero X;
Ex. 2:
Modulo letra X = 240;
Ex. 3:
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 ;
Ex. 2:
x + y;
Esse operador é utilizado para diminuir um valor de outro ou uma variável de outra.
Ex.:
5 - 3;
Ex. 2:
x - y;
Esse operador é utilizado para multiplicar dois valores ou variáveis.
Ex.:
2 * 7;
Ex. 2:
x * y;
Esse operador é utilizado para dividir dois valores ou variáveis.
Ex.:
9 / 7;
Ex. 2:
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
Ex. 2:
/* Isso é
um comentario
que pode ter
varias linhas */
Estado desligado, sem Diferença de Potencial(DDP).
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);
}
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.
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
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)
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).
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).
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).
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
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).
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;
numero pinoLED = 13;
configuracao() {
definirModo(pinoLED, SAIDA);
}
principal() {
ligar(PinoLED);
esperar(1000);
desligar(PinoLED);
esperar(1000);
}
Obs.:
Quando as variáveis número 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;
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.
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.
Ex. 2:
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.
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;
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;
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 (“ ”).
SintaxeUSB.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;
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();
Ex. 2:
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);
}
}
Somos a startup brasiliense que ajuda escolas e educadores a preparar aulas mais tecnológicas, criativas e engajadoras!
© - 2024 | Br.ino - Todos os Direitos Reservados