vscode-arduino

Visual Studio Code extension for Arduino

1,176

228

1,176

297

View on GitHub

Top Related Projects

platformio-core

7,879

Your Gateway to Embedded Software Development Excellence :alien:

Quick Overview

The microsoft/vscode-arduino repository is an extension for Visual Studio Code that provides Arduino development capabilities. It enables users to develop, build, deploy, and debug Arduino sketches directly within VS Code, offering a more powerful and flexible alternative to the traditional Arduino IDE.

Pros

Integrates Arduino development seamlessly into VS Code's rich ecosystem
Supports advanced features like IntelliSense, code navigation, and debugging
Allows for a more customizable development environment compared to the Arduino IDE
Provides easy board and library management through the VS Code interface

Cons

May have a steeper learning curve for beginners compared to the Arduino IDE
Requires additional setup and configuration compared to the standalone Arduino IDE
Some users report occasional stability issues or conflicts with other VS Code extensions
Not all Arduino boards or libraries may be fully supported

Getting Started

Install Visual Studio Code from https://code.visualstudio.com/
Open VS Code and go to the Extensions view (Ctrl+Shift+X)
Search for "Arduino" and install the official Microsoft Arduino extension
Install the Arduino IDE (required for some components)
Open an Arduino sketch or create a new one in VS Code
Use the Arduino extension commands (F1 > Arduino: ...) to configure your board, port, and other settings
Start developing your Arduino project using VS Code's features and the Arduino extension's capabilities

Note: Detailed setup instructions and troubleshooting can be found in the repository's README and documentation.

Competitor Comparisons

arduino-ide

2,377

Arduino IDE 2.x

Pros of Arduino IDE

Native Arduino development environment, providing a more streamlined and focused experience for Arduino projects
Simpler interface, potentially easier for beginners to get started with Arduino programming
Includes built-in examples and libraries specifically tailored for Arduino boards

Cons of Arduino IDE

Limited extensibility compared to VS Code's rich ecosystem of extensions
Less powerful code editing features and customization options
Lacks integrated debugging capabilities found in VS Code with the Arduino extension

Code Comparison

Arduino IDE:

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}

VS Code Arduino:

#include <Arduino.h>

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}

The code structure is similar, but VS Code Arduino typically includes the Arduino.h header by default. Both environments support syntax highlighting, auto-completion, and basic error checking for Arduino projects.

platformio-core

7,879

Your Gateway to Embedded Software Development Excellence :alien:

Pros of PlatformIO Core

Supports a wider range of boards and platforms beyond Arduino
Offers a more powerful and flexible build system
Provides better dependency management and library handling

Cons of PlatformIO Core

Steeper learning curve for beginners
Requires more setup and configuration compared to VSCode-Arduino
May have slower initial project creation due to its comprehensive nature

Code Comparison

VSCode-Arduino:

#include <Arduino.h>

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.println("Hello from VSCode-Arduino!");
  delay(1000);
}

PlatformIO Core:

#include <Arduino.h>

void setup() {
  Serial.begin(115200);
}

void loop() {
  Serial.println("Hello from PlatformIO!");
  delay(1000);
}

The code structure is similar, but PlatformIO often uses a higher baud rate by default. PlatformIO also typically includes a platformio.ini file for project configuration:

[env:uno]
platform = atmelavr
board = uno
framework = arduino

This file specifies the target board, platform, and framework, offering more flexibility and control over the build process.

arduino-cli

4,339

Arduino command line tool

Pros of arduino-cli

Lightweight command-line interface, ideal for automation and CI/CD pipelines
Cross-platform compatibility without GUI dependencies
Easier integration with other tools and scripts

Cons of arduino-cli

Lacks visual debugging and integrated development environment
Steeper learning curve for beginners compared to GUI-based tools
Limited built-in board management features

Code Comparison

vscode-arduino:

const vscode = require('vscode');
const ArduinoContext = require('./arduinoContext');

function activate(context) {
    ArduinoContext.initialize(context);
}

arduino-cli:

package main

import (
    "github.com/arduino/arduino-cli/cli"
)

func main() {
    cli.Execute()
}

The vscode-arduino extension integrates directly with VS Code's API, providing a rich GUI experience. In contrast, arduino-cli is a standalone command-line tool written in Go, offering more flexibility for integration into various workflows and systems.

While vscode-arduino offers a more user-friendly interface for beginners and visual debugging capabilities, arduino-cli excels in automation, scripting, and headless environments. The choice between the two depends on the specific use case and user preferences.

Arduino_Core_STM32

2,804

STM32 core support for Arduino

Pros of Arduino_Core_STM32

Specifically designed for STM32 microcontrollers, offering optimized support and features
Provides a wide range of STM32-specific libraries and examples
Allows for more direct hardware access and configuration of STM32 peripherals

Cons of Arduino_Core_STM32

Limited to STM32 microcontrollers, lacking the versatility of vscode-arduino
May have a steeper learning curve for users unfamiliar with STM32 architecture
Smaller community and potentially fewer resources compared to the more general-purpose vscode-arduino

Code Comparison

Arduino_Core_STM32:

#include "stm32f4xx_hal.h"

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
  delay(1000);
}

vscode-arduino:

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}

The Arduino_Core_STM32 code uses STM32-specific HAL functions, allowing for more direct hardware control, while the vscode-arduino code uses standard Arduino functions, offering better portability across different boards.

arduino-esp32

13,492

Arduino core for the ESP32

Pros of arduino-esp32

Specifically designed for ESP32 microcontrollers, offering optimized support and features
Includes libraries and tools tailored for ESP32 development, such as WiFi and Bluetooth functionality
Actively maintained by Espressif, the manufacturer of ESP32 chips, ensuring up-to-date support

Cons of arduino-esp32

Limited to ESP32 development, lacking support for other Arduino-compatible boards
May have a steeper learning curve for users unfamiliar with ESP32-specific features
Potentially less integrated with Visual Studio Code compared to vscode-arduino

Code Comparison

arduino-esp32:

#include <WiFi.h>

void setup() {
  WiFi.begin("SSID", "PASSWORD");
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
  }
}

vscode-arduino:

#include <Arduino.h>

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}

The arduino-esp32 example demonstrates WiFi connectivity, a key feature of ESP32 boards. The vscode-arduino example shows a basic LED blink sketch, which is more generic and applicable to various Arduino boards.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Visual Studio Code extension for Arduino (deprecated)

â ï¸ Warning â ï¸

This extension is deprecated and no longer maintained. We recommend existing customers to use the Arduino IDE software.

This extension will no longer be available on the marketplace as of 10/1/2024, please see details here.

Welcome to the Visual Studio Code extension for Arduino ^preview ! The Arduino extension makes it easy to develop, build, and deploy your Arduino sketches in Visual Studio Code, with a rich set of functionalities. These include:

IntelliSense and syntax highlighting for Arduino sketches
Verify and upload your sketches in Visual Studio Code
Built-in board and library manager
Built-in example list
Built-in serial monitor
Snippets for sketches
Automatic Arduino project scaffolding
Command Palette (F1) integration of frequently used commands (e.g. Verify, Upload...)

Prerequisites

Either the legacy Arduino IDE or Arduino CLI are required. The recommended approach is to use the version of Arduino CLI that comes bundled with the extension, which works out of the box. Support for the legacy Arduino IDE will be removed in a future version of the extension.

Arduino CLI

To use the bundled version of Arduino CLI, arduino.useArduinoCli should be true, and arduino.path and arduino.commandPath should be empty or unset. arduino.useArduinoCli defaults to false while we deprecate support for the Arduino IDE, but there will be a prompt when the extension first activates to switch to the Arduino CLI.

If you want to use a custom version of Arduino CLI, it can be downloaded from the repository's release page. For custom versions, arduino.path must be set to the directory containing the Arduino CLI executable.

Legacy Arduino IDE

Use of the legacy Arduino IDE is not recommended, and support for the legacy Arduino IDE will be removed in a future version of the extension. The legacy Arduino IDE can be installed from the Arduino download page.

The supported legacy Arduino IDE versions are 1.6.x and up to, but not including, 2.0.0.
The Windows Store's version of the Arduino IDE is not supported because of the sandbox environment that the application runs in.
Note: Arduino IDE 1.8.7 had some breaking changes, causing board package and library installation failures. These failures were corrected in 1.8.8 and later.
Note: Arduino IDE 2.X.Y is not supported and there are no plans for support in the future (issue 1477).

Installation

Open VS Code and press F1 or Ctrl + Shift + P or Cmd + Shift + P to open command palette, select Install Extension and type vscode-arduino.

Or launch VS Code Quick Open (Ctrl + P or Cmd + P ), paste the following command, and press enter.

ext install vscode-arduino

You can also install directly from the Marketplace within Visual Studio Code, searching for Arduino.

Get Started

You can find code samples and tutorials each time that you connect a supported device. Alternatively you can visit our IoT Developer Blog Space or Get Started Tutorials.

Commands

This extension provides several commands in the Command Palette (F1 or Ctrl + Shift + P or Cmd + Shift + P) for working with *.ino files:

Arduino: Board Manager: Manage packages for boards. You can add 3rd party Arduino board by configuring Additional Board Manager URLs in the board manager.
Arduino: Change Board Type: Change board type or platform.
Arduino: Change Timestamp Format: Change format of timestamp printed before each line of Serial Monitor output.
Arduino: Close Serial Monitor: Stop the serial monitor and release the serial port.
Arduino: Examples: Show list of examples.
Arduino: Initialize: Scaffold a VS Code project with an Arduino sketch.
Arduino: Library Manager: Explore and manage libraries.
Arduino: Open Serial Monitor: Open the serial monitor in the integrated output window.
Arduino: Select Serial Port: Change the current serial port.
Arduino: Upload: Build sketch and upload to Arduino board.
Arduino: CLI Upload: Upload complied code without building sketch (CLI only).
Arduino: Upload Using Programmer: Upload using an external programmer.
Arduino: CLI Upload Using Programmer: Upload using an external programmer without building sketch (CLI only).
Arduino: Verify: Build sketch.
Arduino: Rebuild IntelliSense Configuration: Forced/manual rebuild of the IntelliSense configuration. The extension analyzes Arduino's build output and sets the IntelliSense include paths, defines, compiler arguments accordingly.

Keybindings

Arduino: Upload Alt + Cmd + U or Alt + Ctrl + U
Arduino: Verify Alt + Cmd + R or Alt + Ctrl + R
Arduino: Rebuild IntelliSense Configuration Alt + Cmd + I or Alt + Ctrl + I

Options

Option	Description
`arduino.useArduinoCli`	Whether to use the Arduino CLI (`true`) or the legacy Arduino IDE (`false`) -- defaults to `false`. If using `true`, either leave the `arduino.path` and `arduino.commandPath` values unset to use the bundled version of Arduino CLI, or point them at a custom version of Arduino CLI. Note that a future version of the extension will change this default to `true` and remove support for legacy Arduino IDE.
`arduino.path`	Path to the Arduino installation. You can use a custom version of Arduino by modifying this setting to include the full path. Example: `C:\\Program Files\\Arduino` for Windows, `/Applications` for Mac, `/home/<username>/Downloads/arduino-1.8.1` for Linux. (Requires a restart after change). The default value is automatically detected from your legacy Arduino IDE installation path. To use the Arduino CLI, use the path that contains the `arduino-cli` executable (e.g. `/usr/local/bin`), or leave it unset to use the bundled version of Arduino CLI.
`arduino.commandPath`	Path to an executable (or script) relative to `arduino.path`. The default value is `arduino_debug.exe` for Windows, `Contents/MacOS/Arduino` for Mac and `arduino` for Linux, You also can use a custom launch script to run Arduino by modifying this setting. (Requires a restart after change) Example: `run-arduino.bat` for Windows, `Contents/MacOS/run-arduino.sh` for Mac and `bin/run-arduino.sh` for Linux. To use the bundled version of Arduino CLI, leave this option unset. To use a custom version of Arduino CLI, use `arduino-cli`.
`arduino.additionalUrls`	Additional Boards Manager URLs for 3rd party packages as a string array. The default value is empty.
`arduino.logLevel`	CLI output log level. Could be info or verbose. The default value is `"info"`.
`arduino.clearOutputOnBuild`	Clear the output logs before uploading or verifying. Default value is `false`.
`arduino.allowPDEFiletype`	Allow the VSCode Arduino extension to open .pde files from pre-1.0.0 versions of Arduino. Note that this will break Processing code. Default value is `false`.
`arduino.enableUSBDetection`	Enable/disable USB detection from the VSCode Arduino extension. The default value is `true`. When your device is plugged in to your computer, it will pop up a message "`Detected board ****, Would you like to switch to this board type`". After clicking the `Yes` button, it will automatically detect which serial port (COM) is connected a USB device. If your device does not support this feature, please provide us with the PID/VID of your device; the code format is defined in `misc/usbmapping.json`.To learn more about how to list the vid/pid, use the following tools: https://github.com/EmergingTechnologyAdvisors/node-serialport `npm install -g serialport` `serialport-list -f jsonline`
`arduino.disableTestingOpen`	Enable/disable automatic sending of a test message to the serial port for checking the open status. The default value is `false` (a test message will be sent).
`arduino.skipHeaderProvider`	Enable/disable the extension providing completion items for headers. This functionality is included in newer versions of the C++ extension. The default value is `false`.
`arduino.disableIntelliSenseAutoGen`	When `true` vscode-arduino will not auto-generate an IntelliSense configuration (i.e. `.vscode/c_cpp_properties.json`) by analyzing Arduino's compiler output.
`arduino.analyzeOnOpen`	When true, automatically run analysis when the project is opened. Only works when `arduino.analyzeOnSettingChange` is true.
`arduino.analyzeOnSettingChange`	When true, automatically run analysis when board, configuration, or sketch settings are changed.

The following Visual Studio Code settings are available for the Arduino extension. These can be set in global user preferences Ctrl + , or Cmd + , or workspace settings (.vscode/settings.json). The latter overrides the former.

{
    "arduino.useArduinoCli": true,
    "arduino.logLevel": "info",
    "arduino.allowPDEFiletype": false,
    "arduino.enableUSBDetection": true,
    "arduino.disableTestingOpen": false,
    "arduino.skipHeaderProvider": false,
    "arduino.additionalUrls": [
        "https://raw.githubusercontent.com/VSChina/azureiotdevkit_tools/master/package_azureboard_index.json",
        "http://arduino.esp8266.com/stable/package_esp8266com_index.json"
    ],
}

The following settings are as per sketch settings of the Arduino extension. You can find them in .vscode/arduino.json under the workspace.

{
    "sketch": "example.ino",
    "port": "COM5",
    "board": "adafruit:samd:adafruit_feather_m0",
    "output": "../build",
    "prebuild": "./prebuild.sh",
    "postbuild": "./postbuild.sh",
    "intelliSenseGen": "global"
}

sketch - The main sketch file name of Arduino.
port - Name of the serial port connected to the device. Can be set by the Arduino: Select Serial Port command. For Mac users could be "/dev/cu.wchusbserial1420".
board - Currently selected Arduino board alias. Can be set by the Arduino: Change Board Type command. Also, you can find the board list there.
output - Arduino build output path. If not set, Arduino will create a new temporary output folder each time, which means it cannot reuse the intermediate result of the previous build leading to long verify/upload time, so it is recommended to set the field. Arduino requires that the output path should not be the workspace itself or in a subfolder of the workspace, otherwise, it may not work correctly. By default, this option is not set. It's worth noting that the contents of this file could be deleted during the build process, so pick (or create) a directory that will not store files you want to keep.
prebuild - External command which will be invoked before any sketch build (verify, upload, ...). For details see the Pre- and Post-Build Commands section.
postbuild - External command to be run after the sketch has been built successfully. See the afore mentioned section for more details.
intelliSenseGen - Override the global setting for auto-generation of the IntelliSense configuration (i.e. .vscode/c_cpp_properties.json). Three options are available:
- "global": Use the global settings (default)
- "disable": Disable the auto-generation even if globally enabled
- "enable": Enable the auto-generation even if globally disabled
buildPreferences - Set Arduino preferences which then are used during any build (verify, upload, ...). This allows for extra defines, compiler options or includes. The preference key-value pairs must be set as follows:

    "buildPreferences": [
        ["build.extra_flags", "-DMY_DEFINE=666 -DANOTHER_DEFINE=3.14 -Wall"],
        ["compiler.cpp.extra_flags", "-DYET_ANOTER=\"hello\""]
    ]
}

Known limitations/restrictions

Header files to include in a .ino sketch have to be in a sub-directory (e.g. put a header into foo/foo.h and then use #include foo/foo.h). Without this subdirectory (e.g. foo.h directly next to the .ino file using #include "foo.h"), the compile step will fail. (issue 1389

Pre- and Post-Build Commands

On Windows the commands run within a cmd-, on Linux and OSX within a bash-instance. Therefore your command can be anything what you can run within those shells. Instead of running a command you can invoke a script. This makes writing more complex pre-/post-build mechanisms much easier and opens up the possibility to run python or other scripting languages. The commands run within the workspace root directory and vscode-arduino sets the following environment variables: VSCA_BUILD_MODE The current build mode, one of Verifying, Uploading, Uploading (programmer) or Analyzing. This allows you to run your script on certain build modes only. VSCA_SKETCH The sketch file relative to your workspace root directory. VSCA_BOARD Your board and configuration, e.g. arduino:avr:nano:cpu=atmega328. VSCA_WORKSPACE_DIR The absolute path of your workspace root directory. VSCA_LOG_LEVEL The current log level. This allows you to control the verbosity of your scripts. VSCA_SERIAL The serial port used for uploading. Not set if you haven't set one in your arduino.json. VSCA_BUILD_DIR The build directory. Not set if you haven't set one in your arduino.json.

For example under Windows the following arduino.json setup

{
    "board": "arduino:avr:nano",
    "sketch": "test.ino",
    "configuration": "cpu=atmega328",
    "prebuild": "IF \"%VSCA_BUILD_MODE%\"==\"Verifying\" (echo VSCA_BUILD_MODE=%VSCA_BUILD_MODE% && echo VSCA_BOARD=%VSCA_BOARD%)"
}

will produce

[Starting] Verifying sketch 'test.ino'
Running pre-build command: "IF "%VSCA_BUILD_MODE%"=="Verifying" (echo VSCA_BUILD_MODE=%VSCA_BUILD_MODE% && echo VSCA_BOARD=%VSCA_BOARD%)"
VSCA_BUILD_MODE=Verifying
VSCA_BOARD=arduino:avr:nano:cpu=atmega328
Loading configuration...
<...>

when verifying.

IntelliSense

vscode-arduino auto-configures IntelliSense by default. vscode-arduino analyzes Arduino's compiler output by running a separate build and generates the corresponding configuration file at .vscode/c_cpp_properties.json. vscode-arduino tries as hard as possible to keep things up to date, e.g. it runs the analysis when switching the board or the sketch.

It doesn't makes sense though to run the analysis repeatedly. Therefore if the workspace reports problems ("squiggles") - for instance after adding new includes from a new library - run the analysis manually:

Manual rebuild: Arduino: Rebuild IntelliSense Configuration, Keybindings: Alt + Cmd + I or Alt + Ctrl + I

When the analysis is invoked manually it ignores any global and project specific disable.

IntelliSense Configurations

vscode-arduino's analysis stores the result as a dedicated IntelliSense-configuration named Arduino. You have to select it from the far right of the status bar when you're in one of your source files as shown here:

74001156-cfce8280-496a-11ea-9b9d-7d30c83765c1

This system allows you to setup and use own IntelliSense configurations in parallel to the automatically generated configurations provided through vscode-arduino. Just add your configuration to c_cpp_properties.json and name it differently from the default configuration (Arduino), e.g. My awesome configuration and select it from the status bar or via the command palette command C/C++: Select a Configuration...

Change Log

See the Change log for details about the changes in each version.

Supported Operating Systems

Currently this extension supports the following operating systems:

Windows 7 and later (32-bit and 64-bit)
macOS 10.10 and later
Ubuntu 16.04
- The extension might work on other Linux distributions, as reported by other users, but without guarantee.

Support

You can find the full list of issues on the Issue Tracker. You can submit a bug or feature suggestion, and participate in community driven discussions.

Development

Installation prerequisites:

Git
Node.js (>= 12.x)
Npm (>= 6.x)

To run and develop, do the following:

git clone https://github.com/microsoft/vscode-arduino
cd vscode-arduino
Run npm i
Run npm i -g gulp
Open in Visual Studio Code (code .)
Press F5 to debug.

To test, press F5 in VS Code with the "Launch Tests" debug configuration.

Code of Conduct

This project has adopted the Microsoft Open Source Code of Conduct. For more information please see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Privacy Statement

The Microsoft Enterprise and Developer Privacy Statement describes the privacy statement of this software.

License

This extension is licensed under the MIT License. Please see the Third Party Notice file for additional copyright notices and terms.

Contact Us

If you would like to help build the best Arduino experience with VS Code, you can reach us directly at gitter chat room.

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot