Olá, como estão? A princípio iremos falar sobre o Tinkercad, ele é um site gratuito da empresa Autodesk. Embora permita realizar modelagem de projetos 3D, montagem e codificação de circuitos eletrônicos, codificação com objetos 3D e realidade aumentada. Em seguida apresentamos algumas vantagens de se utilizar o Tinkercad, após iremos abordar como estar montando e programando circuitos eletrônicos com Arduíno UNO por texto ou blocos.

Algumas das Vantagens de usar Tinkercad

• Permite realizar protótipo eletrônico, codificá-lo e testá-lo com o simulador.
• Pode-se utilizar utilizar a programação por blocos.
• Ótima forma de ensinar eletrônica, programação e modelagem 3D para crianças.
• Permite visualizar como o seu projeto ficará com a ferramenta de realidade aumentada.
• Também possui um sistema que permite você e sua equipe desenvolva o projeto juntos em tempo real.

Interface do Tinkercad

Montagem de Circuitos Eletrônicos

Antes de mais nada o Tinkercad nós permite desenvolver nossos próprios circuitos e testar virtualmente a partir de simulações. Por este motivos o Tinkercad é tão famoso e útil. Então para começar iremos explicar um pouco da sua interface. Assim que você entrar na sua conta ou criá-la, você irá se deparar com a seguinte tela. Nela basta clicar em Circuitos → Criar Circuito.

Em seguida você se deparará com a seguinte tela. Onde:

1. Nome do Projeto.
2. Exibição (circuito, esquemático e lista de componentes).
3. Ferramentas básicas (girar, apagar,  voltar, avançar, comentários, ocultar comentários, cor do jumper e tipo de jumper).
4. Ferramentas para teste (codificação do microcontrolador por bloco ou texto, simulador e exportar projeto).
5. Lista de Componentes (onde terá os componentes disponíveis para serem utilizados e alguns circuitos prontos).

Programação por Blocos

Para ser habilitado o botão código, você precisará de pelo menos 1 microcontrolador na sua área de trabalho, em seguida clique em código. Ele já abrirá com código por bloco. Assim que abrir você se deparará com a seguinte tela, onde:

1. Programação (bloco, bloco + texto ou texto).
2. Categoria de Blocos (pode modificar dependendo o microcontrolador que estiver utilizando).
3. Blocos (todos os blocos pertencentes a essa categoria do microcontrolador).
4. Exportar ou Baixar (abaixa o código-fonte para ser carregado no seu microcontrolador a partir da sua IDE normalmente sendo Arduíno IDE).
5. Seleção de Microcontrolador (caso tenha mais que um microcontrolador em sua área de trabalho, você poderá estar escolhendo qual programará).
6. Ferramentas (diminuir zoom, aumentar zoom, centralizar e apagar blocos).

Normalmente são 6 categorias de blocos existentes (pode mudar conforme o microcontrolador), sendo elas:

• Saída: responsável pelas saídas como por exemplo alterar o estado de um pino digital ou analógico, gerar onda PWM, imprimir monitor serial, entre outros…
• Entrada: responsável pelas entradas de informações como ler um pino digital, leitura da serial, ler sensores, entre outros…
• Notação: responsável por colocar comentários em seus códigos-fontes.
• Controlar: responsável pelas funções de controle do microcontrolador como aguardar um tempo pré-definido, estruturas de repetições, verificações, entre outros…
• Matemática: responsável pelas operações matemáticas e logicas como igual a maior que, somar, subtrair, entre outros…
• Variáveis: responsável por te permitir estar declarando e utilizando suas próprias variáveis.

Programação por Texto

Assim também é possível estar programando por texto no Tinkercad para isso temos que seguir o mesmo passo a passo da programação por blocos. Entretanto temos que estar trocando a programação para texto no canto superior esquerdo.

Em seguida você irá se deparar com a seguinte tela, onde:

1. Programação (bloco, bloco + texto ou texto).
2. Ferramentas (baixar arquivo para carregar no microcontrolador, bibliotecas e modificar tamanho da fonte).
3. Seleção de Microcontrolador (caso tenha mais que um microcontrolador em sua área de trabalho, você poderá estar escolhendo qual programará).
4. Contagem de linhas (exibe o número das linhas).

Montagem do Projeto Tinkercad

Então agora iremos montar um projeto simples para poder demonstrar o funcionamento do Tinkercad. Entretanto para esse projeto iremos precisar de 3 botões, 1 LED difuso, 4 resistores de 220 Ohms e 1 Arduíno UNO.

Em seguida na montagem do projeto iremos conectar os botões na protoboard e ligamos eles aos pinos 2, 3 e 4 do Arduíno UNO. Em cada botão conectamos a um resistor ligado no GND para que assim possamos realizar um PULL-DOWN e no outro terminal entramos com 5V. Por fim no LED conectamos um resistor no catodo e ao GND e o anodo conectamos no pino 5 do Arduíno UNO.

Contudo segue imagem demonstrando a montagem do projeto:

Código-fonte do Projeto no Tinkercad

Após a montagem do projeto, vamos desenvolver um código simples, onde primeiramente iremos demonstrar o código-fonte em texto e em seguida por bloco.

//Variáveis Globais ----------------------------------------------------------------------------------
byte cont = 0;                                                 // Variável Contador
	 
//Setup ----------------------------------------------------------------------------------------------
void setup() {
    Serial.begin(9600);                                        // Inicializa a Serial em 9600
    pinMode(2, INPUT);                                         // Configura pino como INPUT
    pinMode(3, INPUT);                                         // Configura pino como INPUT
    pinMode(4, INPUT);                                         // Configura pino como INPUT
    pinMode(5, OUTPUT);                                        // Configura pino como OUTPUT
}
	 
//Loop -----------------------------------------------------------------------------------------------
void loop() {
    if (digitalRead(2) == HIGH) {                              // Se o botão foi pressionado 
        cont += 1;                                             // Incrementa +1 a cont
        digitalWrite(5, HIGH);                                 // Liga pino 5
        while (!(digitalRead(2) == LOW)) {delay(10);}          // Loop até o botão ser solto
        Serial.println(cont);                                  // Imprime na serial
        digitalWrite(5, LOW);                                  // Desliga pino 5
    }
    else if(digitalRead(3) == HIGH){                           // Se o botão foi pressionado 
        cont += -1;                                            // Decrementa -1 a cont
        digitalWrite(5, HIGH);                                 // Liga pino 5
        while (!(digitalRead(3) == LOW)) {delay(10);}          // Loop até o botão ser solto
        Serial.println(cont);                                  // Imprime na serial
        digitalWrite(5, LOW);                                  // Desliga pino 5
    }
    else if (digitalRead(4) == HIGH) {                         // Se o botão foi pressionado
        cont = 0;                                              // Atribui 0 a cont
        digitalWrite(5, HIGH);                                 // Liga o pino 5
        while (!(digitalRead(4) == LOW)) {delay(10);}          // Loop até o botão ser solto
        Serial.println(cont);                                  // Imprime na serial
        digitalWrite(5, LOW);                                  // Desliga pino 5
    }
}

Vamos dar uma olhada mais de perto no código:

Variáveis Globais

Primeiramente iremos declarar uma variável do tipo byte para armazenar o contador.

//Variáveis Globais ----------------------------------------------------------------------------------
byte cont = 0;                                                 // Variável Contador

Função Setup

Agora na função setup, iremos inicializar a serial com a velocidade de 9600. Em seguida iremos configurar os pinos 2, 3 e 4 como INPUT e o pino 5 como OUTPUT.

//Setup ----------------------------------------------------------------------------------------------
void setup() {
    Serial.begin(9600);                                        // Inicializa a Serial em 9600
    pinMode(2, INPUT);                                         // Configura pino como INPUT
    pinMode(3, INPUT);                                         // Configura pino como INPUT
    pinMode(4, INPUT);                                         // Configura pino como INPUT
    pinMode(5, OUTPUT);                                        // Configura pino como OUTPUT
}

Função Loop

Logo em seguida vamos para função loop, onde iremos verificar qual dos três botões foi pressionado. Contudo caso tenha incrementamos +1 a cont, ligamos o LED, criamos um loop até que o botão seja solto, imprimimos na serial e desligamos o LED. Já se for o segundo ou terceiro botão realizamos o mesmo procedimento, com uma diferença que ao invés de incrementar iremos decrementar -1 ou atribuímos 0 a variável cont.

//Loop -----------------------------------------------------------------------------------------------
void loop() {
    if (digitalRead(2) == HIGH) {                              // Se o botão foi pressionado 
        cont += 1;                                             // Incrementa +1 a cont
        digitalWrite(5, HIGH);                                 // Liga pino 5
        while (!(digitalRead(2) == LOW)) {delay(10);}          // Loop até o botão ser solto
        Serial.println(cont);                                  // Imprime na serial
        digitalWrite(5, LOW);                                  // Desliga pino 5
    }
    else if(digitalRead(3) == HIGH){                           // Se o botão foi pressionado 
        cont += -1;                                            // Decrementa -1 a cont
        digitalWrite(5, HIGH);                                 // Liga pino 5
        while (!(digitalRead(3) == LOW)) {delay(10);}          // Loop até o botão ser solto
        Serial.println(cont);                                  // Imprime na serial
        digitalWrite(5, LOW);                                  // Desliga pino 5
    }
    else if (digitalRead(4) == HIGH) {                         // Se o botão foi pressionado
        cont = 0;                                              // Atribui 0 a cont
        digitalWrite(5, HIGH);                                 // Liga o pino 5
        while (!(digitalRead(4) == LOW)) {delay(10);}          // Loop até o botão ser solto
        Serial.println(cont);                                  // Imprime na serial
        digitalWrite(5, LOW);                                  // Desliga pino 5
    }
}

Assim finalizamos o código-fonte de texto do Arduíno UNO. Contudo para finalizar iremos ver como ficará com a programação por blocos.

Código-fonte do Projeto por Blocos no Tinkercad

O resultado que obtivemos programando por blocos, foi o seguinte.

Para esse projeto utilizamos 2 blocos de saída, 1 de entrada, 4 de controle, 1 de matemática e 3 variáveis, sendo elas:

SAÍDA:

• Imprimir no Monitor Serial: imprime mensagens na serial, função correspondente print ou println.
• Definir pino X como ALTO/BAIXO: define estado do pino função correspondente digitalWrite.

ENTRADA:

• Ler pino digital X: realiza a leitura do estado do pino digital, função correspondente digitalRead.

CONTROLE:

• Aguardar X s/milissegundos: para a execução do programa por um determinado tempo, função correspondente delay ( X × 1000) ou delay.
• Repetir até:  realiza um loop até que a condição seja verdadeira, função correspondente while(!).
• Se: verifica se a condição esteja verdadeira e executa um bloco de comando, função correspondente if.
• Se ou Se não: verifica se a condição é verdadeira e executa um bloco de comando, caso o contrário executa outro bloco de comandos, função correspondente if e else.

MATEMÁTICA:

• X = Y: verifica se um número, variável ou texto é igual a outra.

VARIÁVEIS:

• Criar variável: declaração da variável, função correspondente (tipo) nome_da_variável.
• Variável: valor contido na variável.
• Altera variável por X: altera o valor da variável por outro incrementando-a ou diminuindo ela, função corresponde nome_da_variável+= X.
• Definir variável como X: define o valor da variável pelo passado, função correspondente variável = X.

Agradecemos sua Presença

Por fim, espero que tenham gostado e aprendido. Então compartilhe com seus colegas e deixe um comentário de qual projeto deveria ser o próximo aqui no Blog da WJ Componentes!!
Enfim estarei deixando o arquivo do Arduíno, link dos posts anteriores referentes ao projeto e software e sites utilizados.
Fique à vontade para tirar suas dúvidas nos comentários.

Software e Sites Utilizados

• Tinkercad

Post Relacionados

• Código Morse com Arduíno UNO
  Olá, como estão? Hoje iremos desenvolver um decodificador de código… Leia mais: Código Morse com Arduíno UNO
• Como Programar pelo Celular o Arduíno!
  Olá, como estão? A princípio iremos explicar como programar pelo… Leia mais: Como Programar pelo Celular o Arduíno!
• Como Programar por Blocos
  Olá, como estão? A princípio iremos falar sobre alguns sites… Leia mais: Como Programar por Blocos
• Contador com Botões no Arduíno UNO
  Olá, como estão? A princípio iremos realizar um contador. Entretanto… Leia mais: Contador com Botões no Arduíno UNO
• Jogo da Forca com Arduíno UNO
  Olá, como estão? A princípio iremos falar sobre a Serial… Leia mais: Jogo da Forca com Arduíno UNO

Posts mais Recentes

• Programando Relé RF 433
  1 -Instruções de emparelhamento do modo de alternância Modo de… Leia mais: Programando Relé RF 433
• Acionando motor DC por meio do pino “Touch” do ESP-32
  Neste projeto, vamos explorar uma aplicação ainda mais dinâmica e… Leia mais: Acionando motor DC por meio do pino “Touch” do ESP-32
• Acendendo led RGB por meio do pino “Touch” do ESP-32
  No último post, exploramos o fascinante mundo dos pinos touch… Leia mais: Acendendo led RGB por meio do pino “Touch” do ESP-32
• 
  Utilizando os Pinos touch do ESP32
  Nesse projeto Vamos aprender a usar os pinos touch´s do… Leia mais: Utilizando os Pinos touch do ESP32
• Como Programar e Localizar o Endereço de uma Tela OLED I2C com Arduino
  este guia, vou levá-lo através dos passos para programar uma… Leia mais: Como Programar e Localizar o Endereço de uma Tela OLED I2C com Arduino

Julio Cesar Bonow Manoel

Cursando Engenharia da Computação pelo Centro Universitário Facens e atua no desenvolvimento de projetos na WJ Componentes. Participante da equipe de robótica Omegabotz.