Tutoriais

Arduino IDE 2.0: Conheça o Novo IDE Arduino

Eletrogate 27 de setembro de 2022

Introdução

Neste post iremos poder conhecer todos os novos recursos do Arduino IDE 2.0, a ferramenta de programação mais rápida e poderosa que o clássico Arduino IDE 1.x. O Arduino IDE 2.0 carrega um editor moderno e oferece uma melhor experiência geral do usuário graças a uma interface responsiva e tempo de compilação mais rápido.


Materiais Necessários para os Projetos de Demonstração do Arduino IDE 2.0

Para este post, serão utilizados os seguintes materiais:

cta_cart


História do Arduino IDE 2.0

Embora as versões 1.x do Arduino IDE forneçam uma interface simples e clara, ideal para usuários iniciantes, os mais avançados relatam que os recursos de edição são um pouco limitados em comparação com editores modernos. Isso inclui recursos como recuo de código, dobra de bloco, colchetes de fechamento automático, pesquisa e substituição de expressão regular, alternância de comentários etc.

As versões do IDE 1.x são desenvolvidas em Java e sua base de código monolítica (a interface de usuário e código de acesso aos dados são combinados em um único programa, em uma única plataforma) dificulta a implementação de novos recursos. O Java também está se tornando uma tecnologia obsoleta para aplicativos de desktop e está sendo descontinuado por sistemas operacionais e lojas de aplicativos mais recentes, causando problemas de compatibilidade. Em 2018, foi iniciada a refatoração da cadeia de ferramentas, anunciando uma grande novidade: a arduino-cli. Esta ferramenta de linha de comando da Arduino, escrita em Golang, expõe todas as principais funcionalidades do IDE, fornecendo aos usuários avançados uma ferramenta flexível que pode ser integrada ao IDE de sua escolha.

Em 2019, foi anunciado o lançamento da versão alfa de um novo IDE, construído em cima do arduino-cli e baseado em uma pilha de software moderna e nos frameworks Theia (permite construir IDE’s e ferramentas a partir de tecnologias web modernas) e Electron, sob o codinome Arduino Pro IDE. Assim foi criado o IDE predecessor do Arduino IDE 2.0. Veja o post Nova IDE Arduino – Profissional – PRO IDE, aqui mesmo do Blog Eletrogate, para saber mais sobre esta versão.


Instalando o Novo IDE Arduino 2.0

Requisitos necessários para a instalação

Para cada Sistema Operacional, a instalação do IDE Arduino 2.0 tem determinado requisito:

Windows

É necessário ter Windows 10 ou mais recente com processador de arquitetura de 64 bits.

Linux

É necessário ter processador de arquitetura de 64 bits.

Mac OS X

É necessário a Versão 10.14 (“Mojave”) ou mais recente com processador de arquitetura de 64 bits.

Processo de instalação em uma máquina Windows

  1. Acesse a página de downloads de Softwares da Arduino em https://www.arduino.cc/en/software e vá até a seção do Arduino IDE 2.0.
  2. Acesse o link de download de acordo com o seu sistema operacional:

    Seção de download do Arduino IDE 2.0. Acessada em 06 set. 2022

  3. Após o download, execute o arquivo baixado da página de software:
  4. Siga os passos do utilitário de instalação:

    Passo 1 – Acordo de Licença

    Passo 2 – Opção de Instalação

    Passo 3 – Local de Instalação

    Passo 4 – Progresso de Instalação

    Passo 5 – Conclusão de Instalação

  5. Após a conclusão do utilitário de instalação do Arduino IDE 2.0, ele já se encontra instalado.

Utilizando o Novo IDE Arduino 2.0

Execute o IDE Arduino 2.0 para os próximos passos.

Visão geral do Arduino IDE 2.0

  1. Verificar: compilar o código;
  2. Carregar: carregar o código para a placa;
  3. Selecionar placa e porta: além de permitir selecionar a placa e a porta manualmente, o IDE detecta automaticamente algumas placas, que aparecem aqui (junto com o número da porta);
  4. Abrir Serial Plotter: abre a ferramenta Serial Plotter, como uma nova janela;
  5. Abrir Serial Monitor: abre a ferramenta Serial Monitor, como uma nova guia no console;
  6. Sketchbook: aqui, se encontram todos os sketches armazenados localmente no computador. Além disso, pode-se sincronizar com o Arduino Cloud e obter os esboços do ambiente online;
  7. Gerenciador de Placas: é possível navegar e instalar novos pacotes de placas Arduino ou de terceiros;
  8. Gerenciador de Bibliotecas: é possível navegar e instalar milhares de bibliotecas do Arduino, feitas pelo Arduino e sua comunidade;
  9. Debugger: testar e depurar programas em tempo real;
  10. Pesquisar: localizar determinadas palavras no sketch.

Trocando de idioma no IDE Arduino 2.0

Caso deseje trocar de idioma no IDE Arduino 2.0, navegue no caminho: Arquivo ➜ Preferências. Caso esteja em inglês, siga File ➜ Preferences.

Com a janela de Preferências aberta, em Linguagem do editor (ou em inglês, Language), selecione o idioma desejado. Em seguida, clique em OK. O IDE será reiniciado para aplicar a alteração de idioma.

Fazendo uso do Sketchbook

Ao clicar no botão correspondente ao Sketchbook na barra lateral, é aberta uma guia lateral com os sketches armazenados. Eles são armazenados como arquivos com extensão .ino e devem ser estar em uma pasta com o mesmo nome.

A pasta de armazenamento do Sketchbook pode ser configurada. Navegue em Arquivo ➜ Preferências:

Ao abrir a janela de preferências, informe o local do Sketchbook em Localização dos Sketchbooks:

Como alterar a placa e a porta atual do sketch

Selecione uma placa e uma porta caso queira fazer o upload de um sketch. Agora, se selecionar apenas uma Placa (sem a porta), será possível apenas compilar, mas não carregar o sketch.

Com o IDE Arduino 2.0 aberto, clique em Selecionar placa e porta. Em seguida, clique em Selecione outra placa e porta. No campo de pesquisa, digite o nome da sua placa, como, por exemplo, Arduino Uno. Caso queira ou seja necessário, selecione uma porta serial em portas, como COM3 (é necessário previamente conectar o arduino em porta USB do computador).

Como fazer uso do preenchimento automático

A funcionalidade de Autocompletar, ao escrever código, economiza o tempo do desenvolvedor e fornece uma compreensão de como a linguagem de programação funciona. O Arduino IDE 2.0 vem equipado com esta ferramenta, o que torna a experiência de escrita de código agradável. Antes de utiliza-la, é necessário verificar se o preenchimento automático, está ativo:

  1. Navegue em Arquivo ➜ Preferências.
  2. Em seguida, marque, caso esteja desmarcado, a caixa ao lado de “Dicas do editor”. Após isso, clique no botão “OK” para aplicar as alterações.

Após habilitar o preenchimento automático, é necessário ter uma placa selecionada. Caso não esteja selecionada, siga as orientações do subtópico Como alterar a placa e a porta atual do sketch.

Com a placa selecionada, dentro de void setup(), digite pin e acione “recurso de preenchimento automático”, pressionando, simultaneamente, CTRL + BARRA DE ESPAÇO. Agora, pode-se ver uma lista de sugestões, onde pinMode(uint8_t pin, uint8_t mode) surge como uma. Clicando na seleção ou pressionando a tecla TAB ou ENTER, ela será completada automaticamente. Ao digitar LED e pressionar, simultaneamente, CTRL + BARRA DE ESPAÇO, é sugerido LED_BUILTIN. Ao pressionar TAB, o argumento é completado e o cursor é movido para o próximo.

Como utilizar o gerenciador de placas

O gerenciador de placa é uma ferramenta usada para instalar diferentes núcleos em seu computador local. Explicado de forma simples, um núcleo é escrito e projetado para microcontroladores específicos. O Arduino oferece vários tipos diferentes de placas, e essas placas também podem ter diferentes tipos de microcontroladores. Então, para usar uma placa específica, precisamos instalar um núcleo específico.

Instalando um núcleo

Caso tenha que instalar um núcleo não oficial proveniente de URL’s de suporte a placas de terceiros, é necessário adicionar a URL adicional antes:

  1. Abra a janela preferências, navegando em Arquivo ➜ Preferências.
  2. Adicione a URL adicional em URL’s do Gerenciador de Placas Adicionais, clicando no botão ao lado do campo de inserção:
  3. No campo da nova janela aberta, insira os URL’s separados por quebra de linha. Um exemplo de URL de placa adicional é a correspondente à família de placas ESP32: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json:
  4. Após inserir os URL’s adicionais, confirme as alterações, clicando nos botões OK.

Após, ao clicar no botão correspondente ao Gerenciador de Placas, na barra lateral, é aberta uma guia lateral com uma lista de todos os núcleos disponíveis. Agora, caso queiramos instalar o núcleo ESP32, digite, no campo de pesquisa, o nome ESP32. Quando aparecer o resultado, clique em instalar. Isso iniciará o processo de instalação.

Após a instalação, irá aparecer uma tag chamada INSTALLED. O clique nesta inicia o processo de desinstalação do pacote.

Bibliotecas

As bibliotecas são extensões da API do Arduino que facilitam, por exemplo, o controle de um servo motor, a leitura de sensores específicos ou utilizar um módulo Wi-Fi.

Como utilizar o gerenciador de bibliotecas

Com o editor aberto, clique no botão correspondente ao Gerenciador de Bibliotecas na barra lateral. Ao fazer isto, é aberta uma guia lateral com uma lista de todas as bibliotecas disponíveis. Como exemplificação, iremos instalar uma biblioteca para uso do sensor DHT22. Na barra de pesquisa, digite dht sensor library. Em seguida, clique em Instalar. Isso iniciará o processo de instalação. Se a biblioteca tiver dependência de outra(s) biblioteca(s), clique em Instalar tudo.

Após a instalação, irá aparecer uma tag chamada INSTALLED. O clique nesta inicia o processo de desinstalação da biblioteca.

Incluindo uma biblioteca

Navegue no menu, seguindo o modelo de navegação: Rascunho ➜ Incluir biblioteca ➜ <nome_da_biblioteca>. No caso da biblioteca do sensor DHT22, seria Rascunho ➜ Incluir biblioteca ➜ DHT sensor library:

Exemplos de uma biblioteca

Quase todas as bibliotecas vêm com exemplos já feitos que podem ser usados. Eles podem ser acessados ​​por meio do seguinte modelo de navegação: Arquivo ➜ Exemplos ➜ <Biblioteca> ➜ <Exemplo> . No caso da biblioteca do sensor DHT22, seria: Arquivo ➜ Exemplos ➜ DHT sensor library ➜ DHTtester:

Ao clicar no exemplo, será aberta uma janela.

Como fazer verificação e upload para a placa

Para este tópico, será utilizado o exemplo DHTtester. No tópico Bibliotecas, foi explicado o processo de sua obtenção.

Como única alteração no código original, a taxa da comunicação Serial foi alterada de 9600 para 115200. O código deste exemplo está descrito a seguir:

// Example testing sketch for various DHT humidity/temperature sensors
// Written by ladyada, public domain

// REQUIRES the following Arduino libraries:
// - DHT Sensor Library: https://github.com/adafruit/DHT-sensor-library
// - Adafruit Unified Sensor Lib: https://github.com/adafruit/Adafruit_Sensor

#include "DHT.h"

#define DHTPIN 2     // Digital pin connected to the DHT sensor
// Feather HUZZAH ESP8266 note: use pins 3, 4, 5, 12, 13 or 14 --
// Pin 15 can work but DHT must be disconnected during program upload.

// Uncomment whatever type you're using!
//#define DHTTYPE DHT11   // DHT 11
#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
//#define DHTTYPE DHT21   // DHT 21 (AM2301)

// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 3 (on the right) of the sensor to GROUND (if your sensor has 3 pins)
// Connect pin 4 (on the right) of the sensor to GROUND and leave the pin 3 EMPTY (if your sensor has 4 pins)
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor

// Initialize DHT sensor.
// Note that older versions of this library took an optional third parameter to
// tweak the timings for faster processors.  This parameter is no longer needed
// as the current DHT reading algorithm adjusts itself to work on faster procs.
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(115200);
  Serial.println(F("DHTxx test!"));

  dht.begin();
}

void loop() {
  // Wait a few seconds between measurements.
  delay(2000);

  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float h = dht.readHumidity();
  // Read temperature as Celsius (the default)
  float t = dht.readTemperature();
  // Read temperature as Fahrenheit (isFahrenheit = true)
  float f = dht.readTemperature(true);

  // Check if any reads failed and exit early (to try again).
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println(F("Failed to read from DHT sensor!"));
    return;
  }

  // Compute heat index in Fahrenheit (the default)
  float hif = dht.computeHeatIndex(f, h);
  // Compute heat index in Celsius (isFahreheit = false)
  float hic = dht.computeHeatIndex(t, h, false);

  Serial.print(F("Humidity: "));
  Serial.print(h);
  Serial.print(F("%  Temperature: "));
  Serial.print(t);
  Serial.print(F("°C "));
  Serial.print(f);
  Serial.print(F("°F  Heat index: "));
  Serial.print(hic);
  Serial.print(F("°C "));
  Serial.print(hif);
  Serial.println(F("°F"));
}

O hardware para este exemplo pode ser montado de acordo com o diagrama:

Verificação

A ferramenta de verificação analisa o Sketch, verifica se há erros e o compila. Antes de prosseguir, é necessário verificar se a placa em que será feito o processo de compilação está selecionada. Caso não esteja selecionada, siga as orientações do subtópico Como alterar a placa e a porta atual do sketch. Com o editor aberto, clique no botão correspondente a Verificar. Este botão está localizado na barra de ferramentas, na parte superior. Após algum tempo, pode-se ver, na parte inferior direita, o resultado da compilação (sucesso ou falha).

Carregamento

A ferramenta de upload analisa o Sketch, verifica se há erros, o compila, e carrega-o na placa. Antes de prosseguir, é necessário verificar se a placa em que será feito o processo de compilação está selecionada. Caso não esteja selecionada, siga as orientações do subtópico Como alterar a placa e a porta atual do sketch. Com o editor aberto, clique no botão correspondente ao Carregar. Este botão está localizado na barra de ferramentas, na parte superior. Após algum tempo, pode-se ver, na parte inferior direita, o resultado do carregamento (sucesso ou falha).

Após o upload, siga para o próximo passo, em que será mostrado como utilizar o Monitor Serial para ver os dados impressos através do sketch deste tópico (DHTtester).

Como utilizar o Plotter Serial e o Monitor Serial

Monitor Serial

A ferramenta Monitor Serial permite visualizar o fluxo de dados da placa, utilizando, por exemplo, o comando Serial.print(). É uma ferramenta essencial na hora de criar projetos com Arduino, podendo ser usado como uma ferramenta de depuração, testando conceitos ou para se comunicar diretamente com a placa Arduino. No IDE Arduino 1.x, essa ferramenta estava localizada em uma janela separada. Nesta, está integrada ao editor. Para testa-la, é utilizado o exemplo DHTtester. No tópico Como fazer verificação e upload para a placa, foi explicado o processo de carregamento dele. Com DHTtester carregado, abra o monitor serial, clicando no botão correspondente, a Monitor Serial.

Enviando dados para a Serial

No Arduino IDE 1.x, os dados podem ser enviados para a placa digitando-os no campo na parte superior da janela e clicando no botão Enviar ou pressionando a tecla ENTER. No Arduino IDE 2.0, você deve usar o atalho de teclado CTRL + ENTER.

Plotter Serial

A ferramenta Serial Plotter é uma ótima maneira para visualizar dados usando gráficos e monitorar, por exemplo, picos de tensão. Ela funciona de forma semelhante à ferramenta Serial Monitor, usada para imprimir dados no “estilo terminal”, mas esta é uma ferramenta visual, exibida em uma janela separada. Pode-se monitorar várias variáveis ​​simultaneamente, com opções para habilitar os valores de apenas algumas variáveis. Para usar o Serial Plotter, é preciso criar um esboço e carregá-lo na placa. Este esboço precisa incluir, pelo menos, uma variável numérica , como um int ou float. Como exemplificação, será usado o seguinte hardware:

No seguinte sketch, serão utilizados os valores de leitura do potenciômetro e de um valor aleatório entre 0 e 1023. Para cada valor, é impresso o seu nome. Os valores são separados por vírgulas.

Carregue o código de exemplificação em sua placa ESP32:

#define pinPot1 39  // o GPIO do ESP32 ao qual o potenciômetro está conectado

unsigned long timeLeitura;  // variável para armazenar o timer para leitura periódica dos valores

void setup() {
  Serial.begin(115200);     // configura a taxa de baudrate
  pinMode(pinPot1, INPUT);  // configura o pino como entrada
}

void loop() {
  if (millis() - timeLeitura >= 100)  // se o tempo de millis() subtraído do timer anterior for maior ou igual à 100 (milissegundos), ...
  {
    Serial.print("Potenciometro 1:");   // Imprime o nome da primeiro valor
    Serial.print(analogRead(pinPot1));  // Imprime o primeiro valor: leitura analógica do potenciômetro
    Serial.print(",");                  // Imprime a separação entre valores
    Serial.print("valorAleatorio:");    // Imprime o nome do segundo valor
    Serial.println(random(0, 1023));    // Imprime o segundo valor: valor aleatório entre 0 e 1023
    timeLeitura = millis();             // Atualiza o valor do timer anterior com o valor atual de millis()
  }
}

Ao terminar de carregar o sketch, abra a Serial Plotter, clicando no botão correspondente ao Serial Plotter. Este botão está localizado na barra de ferramentas, na parte superior:

O Serial Plotter tem a funcionalidade de poder habilitar/desabilitar as variáveis, ​​marcando a caixa ao lado do nome da variável:

O Serial Plotter também tem a funcionalidade de Interpolar os valores das variáveis:

O Serial Plotter ainda possui a funcionalidade de pausar o recebimento de valores para que seja possível ver, exatamente, o valor em um determinado ponto do tempo daquele pause:


Outros Recursos do IDE Arduino 2.0

Depuração de placas

A ferramenta de depuração é utilizada para testar e depurar programas. Esta pode ser usada para navegar pela execução destes de maneira controlada, com a ajuda de uma interface de hardware. Isso pode ajudar a entender melhor seu funcionamento, além de ajudar a detectar possíveis falhas e erros de código.

Placas com arquitetura SAMD são compatíveis com a depuração. As seguintes placas utilizam a arquitetura SAMD:

  • Arduino MKR Zero;
  • Arduino MKR Wi-Fi 1010;
  • Arduino MKR FOX 1200;
  • Arduino MKR WAN 1300;
  • Arduino MKR WAN 1310;
  • Arduino MKR GSM 1400;
  • Arduino MKR NB 1500;
  • Arduino MKR VIDOR 4000;
  • Arduino Nano 33 IoT;
  • Arduino Zero.

Estas e outras placas que utilizam a arquitetura SAMD podem ser utilizadas com o depurador do IDE Arduino 2.0.

A Arduino Zero, exclusivamente, possui hardware de depuração embutido. Então, todas as outras placas necessitam de um hardware para depuração. Este hardware pode ser:

Conhecendo o Depurador

A ferramenta de depuração é uma nova ferramenta integrada no Arduino IDE 2.0. Ela pode ser acessada através da barra lateral, à esquerda, no botão correspondente ao Debugger.

Para iniciar a depuração, é necessário clicar no botão Depuração, localizado na barra superior de ferramentas.

Breakpoint’s

Breakpoint’s são utilizados ​​para parar a execução do programa em uma linha específica (ou quando uma condição específica é verificada). Pode-se usar vários deles em um programa (o número é variável, dependendo do processador). Para adicioná-lo ao programa, clique à esquerda da numeração das linhas do sketch. O exemplo à seguir adiciona breakpoints nas linhas 7 e 10:

Para saber mais sobre depuração com o IDE Arduino 2.0, acesse a documentação oficial do Arduino, em docs.arduino.cc/software/ide-v2/tutorials/ide-v2-debugger.

Atualizador de Firmware e Atualizador de Certificados Raiz SSL para placas Arduino WiFi

A ferramenta Atualizador de Firmware permite que se escolha a versão de firmware para a qual deseja atualizar (ou realizar downgrade). Já a ferramenta Atualizador de Certificados Raiz SSL permite atualizar os certificados raiz SSL na placa (adicionando domínios específicos). Ambas as ferramentas foram desenvolvidas para serem utilizadas com placas WiFi. As seguintes placas são compatíveis:

  • Placas baseadas na série NINA-W10 da u-blox:
    • Arduino UNO WiFi Rev 2;
    • Arduino Nano RP2040 Connect;
    • Arduino MKR WiFi 1010;
    • Arduino Nano 33 IoT;
    • Arduino MKR Vidor 4000.
  • Placas baseadas no módulo ATWINC1500:
    • Arduino MKR 1000 WiFi;
    • Arduino WiFi Shield 101.

Atualizador de Firmware

Atualizar o firmware da placa WiFi pode ser útil, por exemplo, para corrigir bugs de hardware ou para ser compatível com uma configuração específica. Por exemplo, para utilizar o recurso de OTA da Arduino Cloud, é necessário atualizar o firmware.

Esta ferramenta pode ser acessada pela navegação em Ferramentas ➜ Atualizador de Firmware WiFi101 / WiFiNiNA.

Na janela aberta, é possível selecionar a placa no menu suspenso. Pressione o botão Verificar Atualizações para verificar se há atualizações. Após isso, é possível selecionar a versão do firmware para a qual deseja fazer upgrade/downgrade. Para saber mais sobre atualização de firmware com o IDE Arduino 2.0, acesse a documentação oficial do Arduino, em docs.arduino.cc/software/ide-v2/tutorials/ide-v2-fw-cert-uploader.

Atualizador de Certificados Raiz SSL

Esta ferramenta pode ser acessada pela navegação em Ferramentas ➜ Enviar certificado Raiz SSL.

Na Janela aberta, é possível adicionar o(s) URL(s) do(s) certificado(s). Selecione a placa no menu suspenso e clique no botão Carregar para fazer o upload do(s) certificado(s).

Sincronizando Sketches entre IDE 2.0 e Arduino Cloud

Com o uso desta ferramenta, é possível sincronizar o Arduino Cloud Sketchbook com os sketches locais. Utilizar esta ferramenta proporciona uma série de benefícios:

  • O desenvolvedor pode codificar seus sketches em qualquer computador: seus esboços são armazenados na nuvem segura do Arduino, o que significa que podem ser recuperados facilmente em qualquer outra estação de trabalho;
  • O desenvolvedor pode codificar seus sketches sem mesmo ter o IDE Arduino instalado: pode-se utilizar o Arduino Web Editor, onde pode-se encontrar seus sketches sincronizados, além de todas as bibliotecas;
  • Não é necessário mais realizar backup de seus sketches: como os sketches estão armazenados na nuvem, eles estão seguros contra perda de trabalho;
  • É possível codificar offline: não é necessário estar sempre online para trabalhar em seus esboços armazenados remotamente, pois, ao trabalhar localmente, seus sketches possuem uma cópia local. Para fazer a cópia local do sketch e para efetuar as alterações, é necessário estar online;
  • É possível compartilhar seus sketches: caso deseje compartilhar seus sketches com alguém, é possível criar um link para seu sketch, tornando-o público, não mais privado. Assim, seu sketch terá um link atualizado com possíveis alterações no código.
  • Este recurso é fornecido gratuitamente: Pode utiliza-lo sem quaisquer restrições. As limitações do plano de nuvem Arduino se aplicam.

Utilizando a ferramenta

Veja o exemplo passo a passo abaixo para a utilização da ferramenta:

  1. É necessário estar logado em uma conta Arduino. Caso não tenha uma, crie-a em login.arduino.cc/login;
  2. Acesse o Cloud Editor e crie um novo sketch. Para isso, clique no botão New Sketch, no canto superior esquerdo:
  3. Renomeie o Sketch criado com um nome a sua escolha. Para isso, clique no nome atual do Sketch e insira o novo nome no campo de inserção:
  4. Escreva, em seu sketch, o seguinte código:
    void setup() {
      pinMode(LED_BUILTIN, OUTPUT);
    }
    
    void loop() {
      digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
      delay(500);
    }

  5. No IDE Arduino 2.0, acesse o Sketchbook, clicando no botão correspondente ao Sketchbook na barra lateral. Verifique, então, se o Sketchbook remoto está ativado. Caso não esteja, ative-o, navegando em Arquivo ➜ Avançado ➜ Exibir/Ocultar Sketchbook remoto:
  6. Com o Sketchbook remoto aberto, clique no botão Entrar para continuar:
  7. Ao clicar no botão da instrução anterior, será aberto uma aba em seu navegador padrão solicitando que você autorize o acesso de sua conta Arduino em seu aplicativo de desktop. Clique em Aceitar. Após aceitar, será recebido, em seu navegador, uma mensagem, como na seguinte imagem:
  8. Agora que sua conta Arduino está sincronizada com o seu IDE Arduino 2.0, é possível fazer a cópia local (Pulling) para que possamos edita-lo. Na aba do Sketchbook remoto, clique em Baixar Sketch:
  9. Após feita a cópia local, podemos edita-la. Para isso, clique duas vezes, seguidas, sobre o nome do sketch (no caso, blink_500). Isso fará com que se abra uma janela com o sketch:
  10. Com o sketch aberto, podemos edita-lo. Para exemplificação, adicionamos comentários nas linhas do Sketch:
    void setup() {
      pinMode(LED_BUILTIN,
              OUTPUT);  // configura o pino do LED como saída
    }
    
    void loop() {
      digitalWrite(LED_BUILTIN,
                   !digitalRead(LED_BUILTIN));  // define o estado do pino do LED
                                                // como o contrário de sua leitura
    
      delay(500);  // faz uma pausa de 500 milissegundos
    }

  11. Após a edição, é necessário enviar as alterações (Pushing) ao Arduino Cloud. Na aba do Sketchbook remoto, clique em Push Sketch. Isso fará com que o IDE solicite confirmação de envio. Clique em Enviar:
  12. Agora que foram enviadas as alterações para o Arduino Cloud, pode-se verificar se as alterações foram bem-sucedidas. Acesse o Cloud Editor:

Limitações da ferramenta

Caso haja alterações em um sketch em várias estações de trabalho simultaneamente, o último dispositivo que enviar as alterações substituirá as alterações dos outros dispositivos.


Contribuindo com o Novo IDE Arduino 2.0

Relatando problemas (bugs) no Arduino IDE 2.0 através do GitHub

Se você encontrou um problema e deseja relata-lo, você pode enviá-lo ao rastreador de problemas do repositório do IDE Arduino 2.0, disponibilizado em github.com/arduino/arduino-ide/issues. Algumas regras devem ser seguidas:

  • Antes de postar um problema, verifique se não existem relatos deste. Existindo, não crie um novo post: contribua no já existente;
  • Lembre-se de incluir o máximo de detalhes possível sobre a configuração do hardware, o código e as etapas para reproduzir o problema.

Siga os passos abaixo para relatar um problema:

  1. É necessário ter uma conta GitHub para relatar um problema. Caso não tenha uma conta GitHub, crie uma em github.com/signup;
  2. Com sua conta GitHub logada, acesse github.com/arduino/arduino-ide/issues. Em seguida, clique no botão New issue, localizado no canto superior direito;
  3. Em seguida, clique na opção corresponde: Relatório de erro (1), Solicitação de Recurso (2) ou Denunciar uma vulnerabilidade de segurança (3). Neste exemplo, clicamos na opção Relatório de erro (1):
  4. Insira as informações necessárias no formulário que se abrir:
    1. Título: título do problema;
    2. Descreva o problema: uma descrição do problema;
    3. Reproduzir: conjunto específico de etapas que se possa seguir para reproduzir o problema.
    4. Comportamento esperado: comportamento que se esperava que acontecesse depois de seguir as instruções do passo 3;
    5. Versão do Arduino IDE: a versão do IDE Arduino que se estava usando no momento do problema ter ocorrido;
    6. Sistema operacional e versão: qual sistema operacional e sua versão que estava usando no momento do problema ter ocorrido;
    7. Contexto adicional: qualquer informação adicional;
    8. Lista de verificação de problemas: itens a serem cumpridos antes de criar o relatório de problema;
    9. Enviar novo problema: botão para criar o relatório do novo problema.
  5. Após inserir as informações necessárias, envie o novo problema.

Relatando problemas no Arduino IDE 2.0 através do Fórum Arduino

Também é possível relatar problemas no Arduino IDE através do Fórum Arduino.

  1. É necessário estar logado em uma conta Arduino. Caso não tenha uma, crie-a em login.arduino.cc/login;
  2. Acesse o Fórum Arduino IDE 2.0 e crie um novo tópico. Para isso, clique no botão New Topic no canto superior direito:
  3. Insira as informações necessárias no formulário que se abrir:
    1. Título: o título do problema;
    2. Categoria do tópico: não altere esta opção para a criação do relatório do problema;
    3. Texto do tópico: descreva aqui o problema, o conjunto específico de etapas que se possa seguir para reproduzir o problema, o comportamento que se esperava que acontecesse depois de seguir as etapas e as informações da Versão do Arduino IDE e do Sistema Operacional;
    4. Criar novo tópico: botão para criar o relatório do novo problema.

Conclusão

Com isto, concluímos este post sobre a nova versão aprimorada com recursos para atrair os desenvolvedores mais avançados mantendo a continuidade com o simples e clássico do IDE do Arduino.

Curtiu o post? Avalie e deixe um comentário! Siga-nos também no Instagram e nos marque quando fizer algum projeto nosso: @eletrogate. Até a próxima!


Sobre o Autor


Michel Galvão

Hobbysta em Sistemas Embarcados e IoT. Tem experiência em Automação Residencial e Agrícola.


Eletrogate

27 de setembro de 2022

A Eletrogate é uma loja virtual de componentes eletrônicos do Brasil e possui diversos produtos relacionados à Arduino, Automação, Robótica e Eletrônica em geral.

Tenha a Metodologia Eletrogate dentro da sua Escola! Conheça nosso Programa de Robótica nas Escolas!

Eletrogate Robô

Cadastre-se e fique por
dentro de novidades!