Arduino

Pros of arduino-esp32

• Specifically optimized for ESP32 microcontrollers, offering better performance and feature support
• Includes built-in Wi-Fi and Bluetooth functionality
• Provides access to ESP32-specific features like touch sensors and deep sleep modes

Cons of arduino-esp32

• Limited to ESP32 boards, reducing hardware flexibility compared to Arduino
• May have a steeper learning curve for users familiar with standard Arduino
• Potentially less stable due to more frequent updates and changes

Code Comparison

Arduino (Blink example):

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

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

arduino-esp32 (Wi-Fi scan example):

#include <WiFi.h>

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
}

void loop() {
  int n = WiFi.scanNetworks();
  Serial.println("Scan done");
  if (n == 0) {
    Serial.println("No networks found");
  } else {
    Serial.print(n);
    Serial.println(" networks found");
  }
  delay(5000);
}

Pros of PlatformIO Core

• Multi-platform support: Works with various boards and frameworks beyond Arduino
• Dependency management: Built-in library manager and package handling
• Command-line interface: Enables automation and integration with other tools

Cons of PlatformIO Core

• Steeper learning curve: More complex setup and configuration
• Less beginner-friendly: Requires more technical knowledge
• Smaller community: Fewer resources and tutorials available

Code Comparison

Arduino:

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

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

PlatformIO:

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

[env:esp32]
platform = espressif32
board = esp32dev
framework = arduino

The Arduino example shows a simple sketch, while the PlatformIO example demonstrates a project configuration file supporting multiple boards. PlatformIO's approach allows for easier management of multi-board projects and dependencies.

Pros of Arduino_Core_STM32

• Supports a wide range of STM32 microcontrollers, offering more hardware options
• Provides access to advanced features specific to STM32 chips
• Optimized for STM32 performance, potentially resulting in faster code execution

Cons of Arduino_Core_STM32

• Smaller community and fewer resources compared to the main Arduino platform
• May require additional knowledge of STM32 specifics for advanced usage
• Limited compatibility with some Arduino libraries and shields

Code Comparison

Arduino:

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

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

Arduino_Core_STM32:

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

void loop() {
  digitalToggle(LED_BUILTIN);
  delay(1000);
}

The Arduino_Core_STM32 example uses the digitalToggle() function, which is specific to STM32 and more efficient for toggling pins. This demonstrates how Arduino_Core_STM32 can leverage STM32-specific features while maintaining Arduino-like simplicity.

Pros of CircuitPython

• Easier for beginners with Python-based syntax
• Supports live code editing and REPL for faster development
• Better suited for rapid prototyping and education

Cons of CircuitPython

• Limited to specific microcontrollers, mainly Adafruit boards
• Slower execution speed compared to compiled C++ code
• Smaller ecosystem and community support

Code Comparison

Arduino (C++):

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

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

CircuitPython:

import board
import digitalio
import time

led = digitalio.DigitalInOut(board.LED)
led.direction = digitalio.Direction.OUTPUT

while True:
    led.value = True
    time.sleep(1)
    led.value = False
    time.sleep(1)

The CircuitPython code is more readable and intuitive for beginners, while the Arduino code is more compact and efficient. CircuitPython's use of high-level abstractions (e.g., board.LED) simplifies hardware interaction, whereas Arduino requires explicit pin management. Both examples achieve the same result of blinking an LED, showcasing the different approaches of each platform.

Pros of MicroPython

• Uses Python, a high-level language that's easier to learn and read
• Supports interactive REPL for quick testing and development
• More memory-efficient for complex applications

Cons of MicroPython

• Slower execution speed compared to compiled C++ code
• Limited hardware support compared to Arduino's extensive ecosystem
• Larger firmware size, which may not fit on some microcontrollers

Code Comparison

Arduino (C++):

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

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

MicroPython:

from machine import Pin
import time

led = Pin(25, Pin.OUT)
while True:
    led.on()
    time.sleep(1)
    led.off()
    time.sleep(1)

Both examples blink an LED, but MicroPython's code is more concise and readable. Arduino's setup() and loop() structure is replaced with a simple while loop in MicroPython. The Pin and time modules in MicroPython provide similar functionality to Arduino's pinMode() and delay() functions.