fbpixel
Instalar o IDE PlatformIO no Visual Studio Code

Instalar o IDE PlatformIO no Visual Studio Code

Neste tutorial, vamos configurar o Visual Studio Code para que ele possa executar o C

Hardware

  • Computador
  • Placa Arduino UNO ou outra
  • Cabo USB para ligar a placa Arduino ao PC

Instalação do Visual Studio Code e do IDE PlatformIO

Siga os passos de instalação para descarregar o .Net 6.0

Em seguida, abra o Visual Studio Code.

Procure o IDE PlatformIO no separador “Extensões” na coluna da esquerda do Visual Studio Code e clique em “instalar”.

Depois de instalado, feche e reinicie o Visual Studio Code para que o software seja configurado corretamente com o IDE PlatformIO. Em seguida, você deve ser levado para a página inicial do IDE.

Iniciar o seu primeiro projeto em C com o PlatformIO IDE

Para o fazer, clique em “+ Novo projeto” e preencha a janela que aparece.

Aqui, como exemplo, escolhi uma placa Arduino Uno e a estrutura também será do tipo Arduino, o que significa que as funções setup() e loop() se encontrarão no ficheiro principal. A criação de um projeto pode demorar algum tempo.

No lado esquerdo do nosso espaço de trabalho do projeto, verá várias subpastas. A pasta “src” contém os scripts de origem do projeto, incluindo o ficheiro principal “main.cpp”, no qual vamos escrever o nosso script para programar a nossa placa Arduino Uno. Nesta estrutura pré-construída do Arduino, notará que no cabeçalho do programa a linha de comando “

Introdução a um programa C no PlatformIO IDE

Para testar o seu primeiro projeto C no IDE PlatformIO, carregará um pequeno programa para fazer piscar um LED na placa Arduino Uno e obterá feedback sobre o estado do LED através da ligação série no terminal do Visual Studio Code.

// Ici dans l'entête du programme, on inclut les librairies et prototypes de fonctions nécessaires
#include <Arduino.h>

// Ici on met nos initialisations
void setup() 
{ 
    Serial.begin(9600); //ouverture pour communiquer via le port série
    pinMode(13, OUTPUT); //On initialise le pin 13 qui est associé à la LED en sortie pour pouvoir l'allumer et l'éteindre
} //Fin de la fonction setup()

// Ici dans la fonction loop on vient placer le script qui se répètera en boucle dans l'Arduino
void loop() 
{
  digitalWrite(13,HIGH); //Place le pin digital 13 à l'état HAUT (5V) -> Led allumée
  Serial.println("Led allumée");//Nous renvoie par la liaison série l'état de la Led Allumé
  delay(500); //Met en pause le programme pendant la valeur de 500 en ms

  digitalWrite(13,LOW); //Place le pin digital 13 à l'état BAS (0V) -> Led éteinte
   Serial.println("Led éteinte");//Nous renvoie par la liaison série l'état de la Led éteinte
  delay(500); //Met en pause le programme pendant la valeur de 500 en ms
} // Fin de la fonction

Depois de ter copiado e colado o seu programa, pode carregá-lo. Para carregar o programa, existem atalhos que podem ser activados clicando neles na parte inferior do Studio Visual Code :

  1. compilar o programa ;
  2. compilar, limpar e descarregar o programa para a placa Arduino (a porta USB utilizada é detectada automaticamente);
  3. limpe o Terminal e o cartão do microcontrolador ligado (apague o script nele gravado);
  4. testar o programa ;
  5. abrir um monitor para a ligação série e receber (ou enviar) dados da placa. Quando este “Monitor Série” está aberto, é impossível carregar um programa. Por isso, antes de carregar um novo programa, é necessário fechar o monitor clicando uma vez no terminal e depois premindo Ctrl + C ;
  6. Abre um terminal.

Depois de ter clicado em carregar, deve obter um retorno num terminal a confirmar que a compilação e o carregamento foram bem sucedidos, com o seguinte aspeto:

Em seguida, clique no comando para abrir um Monitor e estabelecer o link serial.

Em seguida, você pode observar o feedback do status do LED ao vivo no monitor.

Como instalar uma biblioteca externa no Visual Studio Code para o IDE PlatformIO

É tudo o que há para fazer. Primeiro, descarregue a sua biblioteca externa. Quando tiver um ficheiro .zipp, tem de o extrair (ou copiar e colar da pasta da biblioteca não comprimida) para essa pasta (neste caso, a biblioteca que vamos utilizar como exemplo é a ServoLib, que é utilizada para facilitar o controlo de servomotores):

Pode aceder à pasta “lib” do seu projeto, concebida para alojar bibliotecas externas, através do Visual Studio Code.

Depois de uma biblioteca ter sido instalada no seu projeto, é necessário incluí-la no cabeçalho do programa, tal como :

Agora tem todas as noções básicas necessárias para começar a utilizar o IDE PlatformIO para programar em C.

Programar um Raspberry Pi Pico com o Arduino IDE

Programar um Raspberry Pi Pico com o Arduino IDE

O Raspberry Pi Pico é uma placa de desenvolvimento baseada no RP2040 programável com o IDE Arduino. Tem um grande número de entradas

Instalar os controladores no computador

O Raspberry Pi Pico é reconhecido como um dispositivo de armazenamento USB Fat32. Por isso, não é necessário instalar controladores especiais para o ligar a um computador. Para converter o RPi Pico numa unidade flash USB:

  • Desligue o Pico da sua fonte de alimentação
  • Premir o botão BOOTSEL
  • Ligue o Pico ao computador utilizando o cabo USB
  • Soltar o botão BOOTSEL

Adicionar manipuladores JSON

Para poder programar outros microcontroladores com o IDE Arduino, é necessário instalar gestores de placas no Arduino que contenham todas as ferramentas necessárias para os programar. Para obter os gestores, é necessário encontrar o URL correspondente. No caso do Raspberry Pi Pico, https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json

N.B.: Se tiver problemas de compilação, verifique se está instalada uma versão anterior do Pico. Se estiver, apague-a manualmente (C:\Users\\AppData\Local\Arduino15\packages\rp2040).

Em seguida, abra a janela Ficheiro>Preferências do software Arduino. Na parte inferior da página, encontrará uma caixa de texto para introduzir o URL: “Additional board manager URL”. (não se esqueça de separar os URLs com uma vírgula “,”)

Instalação de gestores

No separador “Ferramentas”, siga o caminho “Tipo de mapa > Gestor de mapas”. O IDE carregará o catálogo de mapas a partir do URL.

Se procurar o microcontrolador na barra de pesquisa, deve ser apresentado o pacote a instalar.

Selecionar a configuração

Uma vez instalado o pacote de gestão, o microcontrolador deve aparecer nos tipos de placas disponíveis.

Terá então de conhecer as características do seu cartão para selecionar as definições correctas. No entanto, exceto em casos excepcionais, as predefinições funcionarão sem problemas.

Exemplo de código

Pode copiar e colar este código de exemplo para testar a compilação e o descarregamento. Uma lista de bibliotecas Arduino compatíveis com o microcontrolador RP2040 está disponível aqui.

//Constants
#define BRIGHTNESS 200

//Parameters
const int ledPin = 25;

//Variables
bool ledStatus = 0;

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
  //Init led
  pinMode(ledPin, OUTPUT);

}

void loop() {
  testLed();
}

void testLed( ) {
  digitalWrite(ledPin, HIGH);
  Serial.println(F("LED ON"));
  delay(500);
  digitalWrite(ledPin, LOW);
  Serial.println(F("LED OFF"));
  delay(500);
}

Se a transferência funcionar, deve ser apresentada a seguinte mensagem

Resetting COM15
Converting to uf2, output size: 105472, start address: 0x2000
Flashing E: (RPI-RP2)
Wrote 105472 bytes to E:/NEW.UF2

Resultados

Fontes

Programar um Raspberry Pi Pico em C++ com o Visual Studio Code

Programar um Raspberry Pi Pico em C++ com o Visual Studio Code

Vamos ver como programar o microcontrolador Raspberry Pi Pico em C++ utilizando o Visual Studio Code. A placa Raspberry Pi Pico é um microcontrolador baseado no chip RP2040 da Raspberry Pi. É programável em C++ e MicroPython e pode interagir com todo o tipo de equipamentos.

Hardware

  • Computador
  • Raspberry Pi Pico
  • Cabo USB B macho para USB Micro B

Instalar e configurar o Visual Studio Code

Aceda à página de transferência do Visual Studio Code e transfira a versão para o seu sistema operativo.

Inicie o instalador e siga o procedimento

Em Extensões, procure e instale o PlatformIO IDE

Nota: Se a instalação do PlatformIO apresentar um erro, siga as soluções descritas nesta página. Para a solução3: actualize a versão do platformio (ou seja, get-platformio-1.1.2.py)

Criar um projeto para o Raspberry Pi Pico

Cliquez sur l’icone PlatformIO dans la barre à gauche puis sélectionnez Projects & Configuration dans le menu Quick Access. Créer un nouveau projet

Procurar a placa Raspberry Pi Pico e selecionar o Arduino Framework

Procurar a placa Raspberry Pi Pico e selecionar o Arduino Framework

#include <Arduino.h>

//Variables 
bool ledStatus = 0; 

void testLed( ){ 
	digitalWrite(LED_BUILTIN,HIGH); 
  	Serial.println(F("LED ON")); 
	delay(500); 
	digitalWrite(LED_BUILTIN,LOW); 
  	Serial.println(F("LED OFF")); 
	delay(500); 
} 

void setup(){ 
	//Init Serial USB 
	Serial.begin(9600); 
	
	Serial.println(F("Initialize System")); 
	//Init led 
	pinMode(LED_BUILTIN,OUTPUT); 
 
} 
 
void loop(){ 
	testLed(); 
} 

Depois de ter escrito o seu código, pode compilá-lo clicando no ícone “Compilar”.

Depois de ter escrito o seu código, pode compilá-lo clicando no ícone “Compilar”.

Pode então copiar o ficheiro firmware.uf2 para o Raspberry Pi Pico, que passa a ser visto como um dispositivo de armazenamento USB.

Próximos carregamentos

Quando o primeiro código tiver sido carregado no Raspberry Pi Pico, deixará de estar disponível como dispositivo de armazenamento USB. Para carregar um código novamente, é necessário

  • Desligue o RPi Pico e volte a ligá-lo, mantendo premido o botão BOOTSEL. Pode então copiar o ficheiro uf2 compilado.
  • Utilize a função Upload da PlatformIO para programar o Pico com o Visual Studio

N.B.: Se o botão Upload do PlatformIO não funcionar, pode tentar instalar a libUSB com o Zadig

Resultados

Tal como no Arduino, pode ver as mensagens de depuração no monitor de série do PlatformIO.

Fontes

Utilização do AC MotorShield ESP32

Utilização do AC MotorShield ESP32

O ESP32 AC MotorShield é uma placa de extensão que permite a um ESP32 NodeMCU acionar dois motores DC ou um motor de passo. Já vimos como acionar um motor DC utilizando uma ponte H, o que pode exigir muita cablagem quando se utiliza apenas o CI. Para uma aplicação a bordo, como um robô Willy, será necessário acionar vários motores em paralelo. Estão disponíveis protecções para simplificar a montagem.

Hardware

  • Computador
  • NodeMCU ESP32
  • Cabo USB A macho
  • Proteção do motor AC ESP32
  • Motor DC x2 ou Motor de passo x1
  • Fonte de alimentação externa de 9V

 

Princípio de funcionamento

O ESP32 AC MotorShield utiliza a ponte H dupla SN751044NE. Pode acionar motores em direção e velocidade com uma tensão nominal entre 4,5 e 36V e uma corrente de 1A com uma fonte de tensão externa:

  •  até dois motores DC ou um motor de passo bipolar
  • GPIOs disponíveis
  • Barramentos I2C e UART

Diagrama

Compatível com a placa NodeMCU ESP32, o shield é colocado diretamente sobre o microcontrolador. A alimentação eléctrica do motor é ligada ao bloco de terminais VM.

  • 0,4 (motor A
  • 15, 2 (motor B
  • GPIOs disponíveis noutros pinos

No caso de uma blindagem, as ligações são predefinidas. As ligações do motor são detalhadas nos diagramas seguintes.

Nos dois exemplos seguintes, estamos a adicionar uma interface Web que permite que os motores sejam testados em ambos os sentidos de rotação.

Código de gestão para um motor de corrente contínua

Para interagir com o MotorShield ESP32 e acionar motores DC, não utilizamos nenhuma biblioteca em particular. Pode sempre criar a sua própria biblioteca para simplificar o seu código.

#include <WiFi.h>
#include <WebServer.h>
#include <Arduino.h>
#include <analogWrite.h>

#define IN1 34    //sensor
#define OUT1  0   //A+ - Black
#define OUT2  4   //A- - Green
#define OUT3  15  //B+ - Red
#define OUT4  2   //B- - Blue

//Motor param
int Steps = 0;
int Direction = 0;
int speedMotor = 150;

//Wifi
const char *ssid = "****";
const char *password = "*****";

WebServer server(80);

const int led = 2;
int stateMotorA = 0,stateMotorB = 0;
char stateMotorTextA[3][10] = {"STOP","CCW!","CW!"};
char stateMotorTextB[3][10] = {"STOP","CCW!","CW!"};
String sensorValue;

/*********************************************************************************************
 * HANDLE FUNCTIONS
*********************************************************************************************/
void handleRoot()
{
    String page = "<!DOCTYPE html>";

    page += "<html lang='fr'>";

    page += "<head>";
    page += "    <title>ESP32MotorShieldV1</title>";
    page += "    <meta http-equiv='refresh' content='60' name='viewport' content='width=device-width, initial-scale=1' charset='UTF-8' />";
    page += "    <link rel='stylesheet' href='https://www.w3schools.com/w3css/4/w3.css'>";

   page += "<script>";

   page += "function getData() {";
   page += "  var xhttp = new XMLHttpRequest();";
   page += "  xhttp.onreadystatechange = function() {";
   page += "    if (this.readyState == 4 && this.status == 200) {";
   page += "      document.getElementById('SensorValue').innerHTML =this.responseText;";
   page += "      console.log(this.responseText);";
   page += "    }";
   page += "  };";
   page += "  xhttp.open('GET', 'readSensor', true);";
   page += "  xhttp.send();";
   page += "}";

   page += "setInterval(function() {getData();}, 2000);   // Call a function repetatively with 2s interval";

   page += "</script>";
 
    page += "</head>";

    page += "<body>";
    page += "    <div class='w3-card w3-padding-small w3-jumbo w3-center' style='color:#fff; background-color:#3aaa35;'>";
    page += "        <p>Motor State A: "; page += stateMotorTextA[stateMotorA]; + "</p>";
    page += "    </div>";

    page += "    <div class='w3-bar'>";
    page += "        <a href='/lefta' class='w3-bar-item w3-button w3-border w3-jumbo' style='width:33%; height:50%;'>GAUCHE</a>";
    page += "       <a href='/stopa' class='w3-bar-item w3-button w3-border w3-jumbo' style='width:33%; height:50%;'>STOP</a>";
    page += "        <a href='/righta' class='w3-bar-item w3-button w3-border w3-jumbo' style='width:33%; height:50%;'>DROITE</a>";
    page += "    </div>";

    page += "    <div class='w3-card w3-padding-small w3-jumbo w3-center' style='color:#fff; background-color:#3aaa35;'>";
    page += "        <p>Motor State B: "; page += stateMotorTextB[stateMotorB]; + "</p>";
    page += "    </div>";

    page += "    <div class='w3-bar'>";
    page += "        <a href='/leftb' class='w3-bar-item w3-button w3-border w3-jumbo' style='width:33%; height:50%;'>GAUCHE</a>";
    page += "       <a href='/stopb' class='w3-bar-item w3-button w3-border w3-jumbo' style='width:33%; height:50%;'>STOP</a>";
    page += "        <a href='/rightb' class='w3-bar-item w3-button w3-border w3-jumbo' style='width:33%; height:50%;'>DROITE</a>";
    page += "    </div>";
    
    page += "    <div class='w3-card w3-padding-small w3-jumbo w3-center' style='color:#fff; background-color:#3aaa35;'>";
    page += "        <p>Sensor value: <span id='SensorValue'>0</span></p>";
    page += "    </div>";

    page += "    <div class='w3-center w3-padding-16'>";
    page += "        <p>Server hosted on NodeMCU ESP32 - <i>Made by <a href='https://www.aranacorp.com' style='color:#3aaa35;'>AranaCorp</a></i></p>";
    page += "        ";

    page += "    </div>";

    page += "</body>";

    page += "</html>";

    server.setContentLength(page.length());
    server.send(200, "text/html", page);
}

void handleLeftA(){
    stateMotorA = 2;
    digitalWrite(led, HIGH);
    server.sendHeader("Location","/");
    server.send(303);
}

void handleRightA(){
    stateMotorA = 1;
    digitalWrite(led, LOW);
    server.sendHeader("Location","/");
    server.send(303);
}

void handleStopA(){
    stateMotorA = 0;
    digitalWrite(led, HIGH);
    server.sendHeader("Location","/");
    server.send(303);
}


void handleLeftB(){
    stateMotorB = 2;
    digitalWrite(led, HIGH);
    server.sendHeader("Location","/");
    server.send(303);
}

void handleRightB(){
    stateMotorB = 1;
    digitalWrite(led, LOW);
    server.sendHeader("Location","/");
    server.send(303);
}

void handleStopB(){
    stateMotorB = 0;
    digitalWrite(led, HIGH);
    server.sendHeader("Location","/");
    server.send(303);
}

void handleInput() {
 sensorValue = String(analogRead(IN1));
 server.send(200, "text/plain", sensorValue); //Send ADC value only to client ajax request
}

void handleNotFound(){
    digitalWrite(led, HIGH);
    stateMotorA = 0;
    stateMotorB = 0;
    server.send(404, "text/plain", "404: Not found");
}


/*********************************************************************************************
 * MAIN
*********************************************************************************************/
void setup()
{
    pinMode(IN1, INPUT); 
    pinMode(OUT1, OUTPUT); 
    pinMode(OUT2, OUTPUT);

    pinMode(OUT3, OUTPUT);
    pinMode(OUT4, OUTPUT);
    
    Serial.begin(115200);
    delay(1000);
    Serial.println("\n");

    pinMode(led, OUTPUT);
    digitalWrite(led, HIGH);

    WiFi.persistent(false);
    WiFi.begin(ssid, password);
    Serial.print("Tentative de connexion...");

    while (WiFi.status() != WL_CONNECTED)
    {
        Serial.print(".");
        delay(100);
    }

    Serial.println("\n");
    Serial.println("Connexion etablie!");
    Serial.print("Adresse IP: ");
    Serial.println(WiFi.localIP());

    server.on("/", handleRoot);
    server.on("/lefta", handleLeftA);
    server.on("/righta", handleRightA);
    server.on("/stopa", handleStopA);
    server.on("/leftb", handleLeftB);
    server.on("/rightb", handleRightB);
    server.on("/stopb", handleStopB);   
    server.on("/readSensor", handleInput);//To get sensor value update

 
    server.onNotFound(handleNotFound);
    server.begin();

    Serial.println("Serveur web actif!");
}


void loop()
{
    server.handleClient();
    //Handle motor A
    switch(stateMotorA) {
      case 0:
        analogWrite(OUT1, 0);
        analogWrite(OUT2, 0);
        break;
      case 1:
        analogWrite(OUT1, speedMotor);
        analogWrite(OUT2, 0);
        break;
      case 2:
        analogWrite(OUT1, 0);
        analogWrite(OUT2, speedMotor);
        break;
    }
    //Handle motor B
    switch(stateMotorB) {
      case 0:
        analogWrite(OUT3, 0);
        analogWrite(OUT4, 0);
        break;
      case 1:
        analogWrite(OUT3, speedMotor);
        analogWrite(OUT4, 0);
        break;
      case 2:
        analogWrite(OUT3, 0);
        analogWrite(OUT4, speedMotor);
        break;
    }
}

Código de gestão do motor passo-a-passo

Para acionar um motor passo a passo, as bobinas do motor têm de ser activadas numa sequência precisa. Esta sequência é descrita na função step da biblioteca stepper.h.

/*
   Nema   | Board pin | NodeMCU GPIO |  Arduino IDE
   black        A+           0             0
   green        A-           4             4
   red          B+           15            15
   blue         B-           2             2
*/

#include <WiFi.h>
#include <WebServer.h>
#include <Arduino.h>
#include <analogWrite.h>

#include <Stepper.h>

#define IN1 34    //sensor
#define OUT1  0   //A+ - Black
#define OUT2  4   //A- - Green
#define OUT3  15  //B+ - Red
#define OUT4  2   //B- - Blue


//Stepper param
const int stepsPerRevolution = 200;
int speedMotor = 20;
Stepper myStepper(stepsPerRevolution, OUT1, OUT2, OUT3, OUT4);

//Wifi
const char *ssid = "*****";
const char *password = "********";

WebServer server(80);

const int led = 2;
int stateStepper = 0,stateStepperB = 0;
char stateStepperText[3][10] = {"STOP","CCW!","CW!"};
String sensorValue;
  
/*********************************************************************************************
 * HANDLE FUNCTIONS
*********************************************************************************************/
void handleRoot()
{
    String page = "<!DOCTYPE html>";

    page += "<html lang='fr'>";

    page += "<head>";
    page += "    <title>ESP32MotorShieldV1</title>";
    page += "    <meta http-equiv='refresh' content='60' name='viewport' content='width=device-width, initial-scale=1' charset='UTF-8' />";
    page += "    <link rel='stylesheet' href='https://www.w3schools.com/w3css/4/w3.css'>";

   page += "<script>";

   page += "function getData() {";
   page += "  var xhttp = new XMLHttpRequest();";
   page += "  xhttp.onreadystatechange = function() {";
   page += "    if (this.readyState == 4 && this.status == 200) {";
   page += "      document.getElementById('SensorValue').innerHTML =this.responseText;";
   page += "      console.log(this.responseText);";
   page += "    }";
   page += "  };";
   page += "  xhttp.open('GET', 'readSensor', true);";
   page += "  xhttp.send();";
   page += "}";

   page += "setInterval(function() {getData();}, 2000);   // Call a function repetatively with 2s interval";

   page += "</script>";
 
    page += "</head>";

    page += "<body>";
    page += "    <div class='w3-card w3-padding-small w3-jumbo w3-center' style='color:#fff; background-color:#3aaa35;'>";
    page += "        <p>Stepper State: "; page += stateStepperText[stateStepper]; + "</p>";
    page += "    </div>";

    page += "    <div class='w3-bar'>";
    page += "        <a href='/left' class='w3-bar-item w3-button w3-border w3-jumbo' style='width:33%; height:50%;'>GAUCHE</a>";
    page += "       <a href='/stop' class='w3-bar-item w3-button w3-border w3-jumbo' style='width:33%; height:50%;'>STOP</a>";
    page += "        <a href='/right' class='w3-bar-item w3-button w3-border w3-jumbo' style='width:33%; height:50%;'>DROITE</a>";
    page += "    </div>";
    
    page += "    <div class='w3-card w3-padding-small w3-jumbo w3-center' style='color:#fff; background-color:#3aaa35;'>";
    page += "        <p>Sensor value: <span id='SensorValue'>0</span></p>";
    page += "    </div>";

    page += "    <div class='w3-center w3-padding-16'>";
    page += "        <p>Server hosted on NodeMCU ESP32 - <i>Made by <a href='https://www.aranacorp.com' style='color:#3aaa35;'>AranaCorp</a></i></p>";
    page += "        ";

    page += "    </div>";

    page += "</body>";

    page += "</html>";

    server.setContentLength(page.length());
    server.send(200, "text/html", page);
}

void handleLeft(){
    stateStepper = 2;
    digitalWrite(led, HIGH);
    server.sendHeader("Location","/");
    server.send(303);
}

void handleRight(){
    stateStepper = 1;
    digitalWrite(led, LOW);
    server.sendHeader("Location","/");
    server.send(303);
}

void handleStop(){
    stateStepper = 0;
    digitalWrite(led, HIGH);
    server.sendHeader("Location","/");
    server.send(303);
}


void handleInput() {
 sensorValue = String(analogRead(IN1));
 server.send(200, "text/plain", sensorValue); //Send ADC value only to client ajax request
}

void handleNotFound(){
    digitalWrite(led, HIGH);
    stateStepper = 0;
    server.send(404, "text/plain", "404: Not found");
}


/*********************************************************************************************
 * MAIN
*********************************************************************************************/
void setup()
{
    pinMode(IN1, INPUT); 
    
    Serial.begin(115200);
    delay(1000);
    Serial.println("\n");

    pinMode(led, OUTPUT);
    digitalWrite(led, HIGH);

    myStepper.setSpeed(speedMotor);

    WiFi.persistent(false);
    WiFi.begin(ssid, password);
    Serial.print("Tentative de connexion...");

    while (WiFi.status() != WL_CONNECTED)
    {
        Serial.print(".");
        delay(100);
    }

    Serial.println("\n");
    Serial.println("Connexion etablie!");
    Serial.print("Adresse IP: ");
    Serial.println(WiFi.localIP());

    server.on("/", handleRoot);
    server.on("/left", handleLeft);
    server.on("/right", handleRight);
    server.on("/stop", handleStop);  
    server.on("/readSensor", handleInput);//To get sensor value update

 
    server.onNotFound(handleNotFound);
    server.begin();

    Serial.println("Serveur web actif!");
}


void loop()
{
    server.handleClient();
    //Handle Stepper
    switch(stateStepper) {
      case 0:
        //stop
        break;
      case 1:
        myStepper.step(1);
        break;
      case 2:
        myStepper.step(-1);
        break;
    }
}

Aplicações

  • Controlar um robô de duas rodas como o Willy através de uma ligação WiFi ou Bluetooth

Fontes

Programar o Arduino com o Visual Studio Code

Programar o Arduino com o Visual Studio Code

, ,

Vamos ver como programar uma placa Arduino usando o Visual Studio Code, que é uma boa alternativa ao IDE do Arduino. Geralmente, começamos a programar no Arduino usando o IDE oficial, mas pode ser interessante mudar de editor de código para ter acesso a um maior número de funções. Neste artigo, apresentamos a utilização do Visual Studio Code. Existem outros editores, como o Eclipse, Netbeans, Atom.io, etc.

Apresentando o Visual Studio Code

O Visual Studio Code é um editor de código leve e extensível desenvolvido pela Microsoft. O VsCode oferece muitas das mesmas funcionalidades que o IDE Arduino:

  • Conclusão automática
  • Realçar a sintaxe
  • Funcionalidade de depuração
  • Programação em várias linguagens (C++, C
  • Gestão de projectos
  • Gestão de repositórios Git
  • E assim por diante.

É de código aberto e está disponível nas plataformas Windows, Linux e MacOS.

Instalando o Visual Studio Code

Aceda à página de transferência do Visual Studio Code e transfira a versão para o seu sistema operativo.

Inicie o instalador e siga o procedimento

Para comunicar com o Arduino, é necessário instalar a extensão adequada.

Clique no ícone “Gerir” (roda dentada) no canto inferior esquerdo e seleccione Extensões (ou Ctrl+Shift+X)

Em seguida, procure Arduino e seleccione “Arduino for Visual Studio Code”.

Reiniciar o VsCode

Configuração do VsCode para Arduino

Clique no ícone Gerir e seleccione “Comando da paleta” (ou Ctrl+Shift+P)

Pesquise por Arduino e terá acesso a vários comandos relacionados com o Arduino.

Seleccione Arduino Board Config e, em seguida, seleccione o tipo de placa

No canto inferior direito, clique em Select Serial Port (Selecionar porta série) e, em seguida, seleccione a porta série correspondente ao Arduino (aqui, COM5).

No canto inferior direito, clique em Selecionar programador e seleccione “AVRPISP mkII”.

Compilar o código e carregá-lo

Na paleta de comandos (Ctrl+Shift+P), procure por Arduino: Exemplos e, em seguida, escolha Blink ou outro exemplo.

Pode então carregar o código clicando em “Carregar” no canto superior direito.

A consola indica se o código está a ser carregado e pode verificar se o código está carregado na placa Arduino observando o estado do LED.

Modificando um pouco o código, podemos enviar texto para o monitor de série.

int led = 13;

// the setup routine runs once when you press reset:
void setup() {
  Serial.begin(115200);
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  Serial.println("Led is High");
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  Serial.println("Led is Low");

  delay(1000);               // wait for a second

}

Para abrir o monitor de série, prima o ícone Monitor de série, mesmo à direita do tipo de cartão, no canto inferior direito.

Envio de comandos para o monitor de série

Tal como no IDE Arduino, pode enviar comandos através da porta série.

Na paleta de comandos do Arduino, procure “Sedn text to Serial Port”. Aparece uma barra de entrada.

Pode criar um atalho de teclado para abrir este comando mais facilmente. Prima a roda dentada à direita do comando

Fontes

https://code.visualstudio.com/
https://www.aranacorp.com/fr/programmez-avec-arduino/
https://code.visualstudio.com/Download