neulab/tldr huggingface dataset:
│board_nordicnrf52_electronut_blip  │ platform_nordicnrf52 │ On-board │ NRF52840 │ 64MHz     │ 1MB   │ 256KB │
├───────────────────────────────────┼──────────────────────┼──────────┼──────────┼───────────┼───────┼───────┤
│board_nordicnrf52_electronut_papyr │ platform_nordicnrf52 │ On-board │ NRF52840 │ 64MHz     │ 1MB   │ 256KB │
└───────────────────────────────────┴──────────────────────┴──────────┴──────────┴───────────┴───────┴───────┘
Engduino
┌──────────────────────────┬───────────────────┬──────────┬────────────┬───────────┬───────┬────────┐
│Name                      │ Platform          │ Debug    │ MCU        │ Frequency │ Flash │ RAM    │
├──────────────────────────┼───────────────────┼──────────┼────────────┼───────────┼───────┼────────┤
│board_atmelavr_engduinov3 │ platform_atmelavr │ On-board │ ATMEGA32U4 │ 8MHz      │ 28KB  │ 2.50KB │
└──────────────────────────┴───────────────────┴──────────┴────────────┴───────────┴───────┴────────┘
EnviroDIY
┌──────────────────────┬───────────────────┬──────────┬─────────────┬───────────┬───────┬──────┐
│Name                  │ Platform          │ Debug    │ MCU         │ Frequency │ Flash │ RAM  │
├──────────────────────┼───────────────────┼──────────┼─────────────┼───────────┼───────┼──────┤
│board_atmelavr_mayfly │ platform_atmelavr │ On-board │ ATMEGA1284P │ 8MHz      │ 127KB │ 16KB │
└──────────────────────┴───────────────────┴──────────┴─────────────┴───────────┴───────┴──────┘
Espressif
┌─────────────────────────────────┬──────────────────────┬──────────┬───────┬───────────┬───────┬───────┐
│Name                             │ Platform             │ Debug    │ MCU   │ Frequency │ Flash │ RAM   │
├─────────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_esp-wrover-kit │ platform_espressif32 │ On-board │ ESP32 │ 240MHz    │ 4MB   │ 320KB │
├─────────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_esp32dev       │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 4MB   │ 320KB │
└─────────────────────────────────┴──────────────────────┴──────────┴───────┴───────────┴───────┴───────┘
FYSETC
┌────────────────────────────┬───────────────────┬──────────┬────────────┬───────────┬───────┬─────┐
│Name                        │ Platform          │ Debug    │ MCU        │ Frequency │ Flash │ RAM │
├────────────────────────────┼───────────────────┼──────────┼────────────┼───────────┼───────┼─────┤
│board_atmelavr_fysetc_f6_13 │ platform_atmelavr │ On-board │ ATMEGA2560 │ 16MHz     │ 252KB │ 8KB │
└────────────────────────────┴───────────────────┴──────────┴────────────┴───────────┴───────┴─────┘
Fred
┌────────────────────────────┬──────────────────────┬──────────┬───────┬───────────┬───────┬───────┐
│Name                        │ Platform             │ Debug    │ MCU   │ Frequency │ Flash │ RAM   │
├────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_frogboard │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 4MB   │ 320KB │
└────────────────────────────┴──────────────────────┴──────────┴───────┴───────────┴───────┴───────┘
Gimasi
┌───────────────────────────┬───────────────────┬──────────┬────────────┬───────────┬───────┬──────┐
│Name                       │ Platform          │ Debug    │ MCU        │ Frequency │ Flash │ RAM  │
├───────────────────────────┼───────────────────┼──────────┼────────────┼───────────┼───────┼──────┤
│board_atmelsam_tuinozero96 │ platform_atmelsam │ External │ SAMD21G18A │ 48MHz     │ 256KB │ 32KB │
└───────────────────────────┴───────────────────┴──────────┴────────────┴───────────┴───────┴──────┘
Heltec Automation
┌─────────────────────────────────────────┬──────────────────────┬──────────┬───────┬───────────┬───────┬───────┐
│Name                                     │ Platform             │ Debug    │ MCU   │ Frequency │ Flash │ RAM   │
├─────────────────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_heltec_wifi_lora_32    │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 4MB   │ 320KB │
├─────────────────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_heltec_wifi_lora_32_V2 │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 8MB   │ 320KB │
├─────────────────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_heltec_wireless_stick  │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 8MB   │ 320KB │
└─────────────────────────────────────────┴──────────────────────┴──────────┴───────┴───────────┴───────┴───────┘
Hornbill
┌───────────────────────────────────┬──────────────────────┬──────────┬───────┬───────────┬───────┬───────┐
│Name                               │ Platform             │ Debug    │ MCU   │ Frequency │ Flash │ RAM   │
├───────────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_hornbill32dev    │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 4MB   │ 320KB │
├───────────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_hornbill32minima │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 4MB   │ 320KB │
└───────────────────────────────────┴──────────────────────┴──────────┴───────┴───────────┴───────┴───────┘
Infineon
┌──────────────────────────────────────┬──────────────────────┬──────────┬─────────┬───────────┬────────┬────────┐
│Name                                  │ Platform             │ Debug    │ MCU     │ Frequency │ Flash  │ RAM    │
├──────────────────────────────────────┼──────────────────────┼──────────┼─────────┼───────────┼────────┼────────┤
│board_infineonxmc_xmc1100_boot_kit    │ platform_infineonxmc │ On-board │ XMC1100 │ 32MHz     │ 64KB   │ 16KB   │
├──────────────────────────────────────┼──────────────────────┼──────────┼─────────┼───────────┼────────┼────────┤
│board_infineonxmc_xmc1100_h_bridge2go │ platform_infineonxmc │ On-board │ XMC1100 │ 32MHz     │ 64KB   │ 16KB   │
├──────────────────────────────────────┼──────────────────────┼──────────┼─────────┼───────────┼────────┼────────┤
│board_infineonxmc_xmc1100_xmc2go      │ platform_infineonxmc │ On-board │ XMC1100 │ 32MHz     │ 64KB   │ 16KB   │
├──────────────────────────────────────┼──────────────────────┼──────────┼─────────┼───────────┼────────┼────────┤
│board_infineonxmc_xmc1300_boot_kit    │ platform_infineonxmc │ On-board │ XMC1300 │ 32MHz     │ 64KB   │ 16KB   │
├──────────────────────────────────────┼──────────────────────┼──────────┼─────────┼───────────┼────────┼────────┤
│board_infineonxmc_xmc1300_sense2gol   │ platform_infineonxmc │ On-board │ XMC1300 │ 32MHz     │ 32KB   │ 16KB   │
├──────────────────────────────────────┼──────────────────────┼──────────┼─────────┼───────────┼────────┼────────┤
│board_infineonxmc_xmc1400_boot_kit    │ platform_infineonxmc │ On-board │ XMC1400 │ 48MHz     │ 1.95MB │ 16KB   │
├──────────────────────────────────────┼──────────────────────┼──────────┼─────────┼───────────┼────────┼────────┤
│board_infineonxmc_xmc4200_distance2go │ platform_infineonxmc │ On-board │ XMC4200 │ 80MHz     │ 256KB  │ 40KB   │
├──────────────────────────────────────┼──────────────────────┼──────────┼─────────┼───────────┼────────┼────────┤
│board_infineonxmc_xmc4700_relax_kit   │ platform_infineonxmc │ On-board │ XMC4700 │ 144MHz    │ 2.00MB │ 1.95MB │
└──────────────────────────────────────┴──────────────────────┴──────────┴─────────┴───────────┴────────┴────────┘
│board_nxplpc_lpc1768          │ platform_nxplpc   │ On-board │ LPC1768          │ 96MHz     │ 512KB │ 64KB  │
└──────────────────────────────┴───────────────────┴──────────┴──────────────────┴───────────┴───────┴───────┘
NodeMCU
┌──────────────────────────────┬──────────────────────┬──────────┬───────┬───────────┬───────┬───────┐
│Name                          │ Platform             │ Debug    │ MCU   │ Frequency │ Flash │ RAM   │
├──────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_nodemcu-32s │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 4MB   │ 320KB │
└──────────────────────────────┴──────────────────────┴──────────┴───────┴───────────┴───────┴───────┘
Nordic
┌───────────────────────────────────────┬──────────────────────┬──────────┬──────────┬───────────┬───────┬───────┐
│Name                                   │ Platform             │ Debug    │ MCU      │ Frequency │ Flash │ RAM   │
├───────────────────────────────────────┼──────────────────────┼──────────┼──────────┼───────────┼───────┼───────┤
│board_nordicnrf51_nrf51_beacon         │ platform_nordicnrf51 │ On-board │ NRF51822 │ 32MHz     │ 256KB │ 32KB  │
├───────────────────────────────────────┼──────────────────────┼──────────┼──────────┼───────────┼───────┼───────┤
│board_nordicnrf52_thingy_52            │ platform_nordicnrf52 │ External │ NRF52832 │ 64MHz     │ 512KB │ 64KB  │
├───────────────────────────────────────┼──────────────────────┼──────────┼──────────┼───────────┼───────┼───────┤
│board_nordicnrf51_nrf51_dongle         │ platform_nordicnrf51 │ On-board │ NRF51822 │ 32MHz     │ 256KB │ 32KB  │
├───────────────────────────────────────┼──────────────────────┼──────────┼──────────┼───────────┼───────┼───────┤
│board_nordicnrf51_nrf51_mkit           │ platform_nordicnrf51 │ On-board │ NRF51822 │ 16MHz     │ 128KB │ 16KB  │
├───────────────────────────────────────┼──────────────────────┼──────────┼──────────┼───────────┼───────┼───────┤
│board_nordicnrf51_nrf51_dk             │ platform_nordicnrf51 │ On-board │ NRF51822 │ 32MHz     │ 256KB │ 32KB  │
├───────────────────────────────────────┼──────────────────────┼──────────┼──────────┼───────────┼───────┼───────┤
│board_nordicnrf52_nrf52_dk             │ platform_nordicnrf52 │ On-board │ NRF52832 │ 64MHz     │ 512KB │ 64KB  │
├───────────────────────────────────────┼──────────────────────┼──────────┼──────────┼───────────┼───────┼───────┤
│board_nordicnrf52_nrf52840_dk          │ platform_nordicnrf52 │ On-board │ NRF52840 │ 64MHz     │ 1MB   │ 256KB │
├───────────────────────────────────────┼──────────────────────┼──────────┼──────────┼───────────┼───────┼───────┤
│board_nordicnrf52_nrf52840_dk_adafruit │ platform_nordicnrf52 │ On-board │ NRF52840 │ 64MHz     │ 796KB │ 243KB │
└───────────────────────────────────────┴──────────────────────┴──────────┴──────────┴───────────┴───────┴───────┘
OLIMEX
┌───────────────────────────────────┬──────────────────────┬──────────┬───────┬───────────┬───────┬───────┐
│Name                               │ Platform             │ Debug    │ MCU   │ Frequency │ Flash │ RAM   │
├───────────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_esp32-devkitlipo │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 4MB   │ 320KB │
├───────────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_esp32-evb        │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 4MB   │ 320KB │
├───────────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_esp32-gateway    │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 4MB   │ 320KB │
└───────────────────────────────────┴──────────────────────┴──────────┴───────┴───────────┴───────┴───────┘
Particle
┌─────────────────────────────────┬──────────────────────┬──────────┬──────────┬───────────┬───────┬───────┐
│Name                             │ Platform             │ Debug    │ MCU      │ Frequency │ Flash │ RAM   │
├─────────────────────────────────┼──────────────────────┼──────────┼──────────┼───────────┼───────┼───────┤
│board_nordicnrf52_particle_argon │ platform_nordicnrf52 │ External │ NRF52840 │ 64MHz     │ 796KB │ 243KB │
├─────────────────────────────────┼──────────────────────┼──────────┼──────────┼───────────┼───────┼───────┤
│board_nordicnrf52_particle_boron │ platform_nordicnrf52 │ External │ NRF52840 │ 64MHz     │ 796KB │ 243KB │
├─────────────────────────────────┼──────────────────────┼──────────┼──────────┼───────────┼───────┼───────┤
│board_nordicnrf52_particle_xenon │ platform_nordicnrf52 │ External │ NRF52840 │ 64MHz     │ 796KB │ 243KB │
└─────────────────────────────────┴──────────────────────┴──────────┴──────────┴───────────┴───────┴───────┘
Pycom Ltd.
┌────────────────────────┬──────────────────────┬──────────┬───────┬───────────┬───────┬────────┐
│Name                    │ Platform             │ Debug    │ MCU   │ Frequency │ Flash │ RAM    │
├────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼────────┤
│board_espressif32_lopy  │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 4MB   │ 320KB  │
├────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼────────┤
│board_espressif32_lopy4 │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 4MB   │ 1.25MB │
└────────────────────────┴──────────────────────┴──────────┴───────┴───────────┴───────┴────────┘
RoboticsBrno
┌────────────────────────────┬──────────────────────┬──────────┬───────┬───────────┬───────┬───────┐
│Name                        │ Platform             │ Debug    │ MCU   │ Frequency │ Flash │ RAM   │
├────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_alksesp32 │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 4MB   │ 320KB │
└────────────────────────────┴──────────────────────┴──────────┴───────┴───────────┴───────┴───────┘
SG-O
┌──────────────────────────────┬──────────────────────┬──────────┬───────┬───────────┬───────┬───────┐
│Name                          │ Platform             │ Debug    │ MCU   │ Frequency │ Flash │ RAM   │
├──────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_sg-o_airMon │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 4MB   │ 320KB │
└──────────────────────────────┴──────────────────────┴──────────┴───────┴───────────┴───────┴───────┘
SODAQ
┌──────────────────────────────┬───────────────────┬──────────┬─────────────┬───────────┬─────────┬──────┐
│Name                          │ Platform          │ Debug    │ MCU         │ Frequency │ Flash   │ RAM  │
├──────────────────────────────┼───────────────────┼──────────┼─────────────┼───────────┼─────────┼──────┤
│board_atmelsam_sodaq_autonomo │ platform_atmelsam │ External │ SAMD21J18A  │ 48MHz     │ 256KB   │ 32KB │
├──────────────────────────────┼───────────────────┼──────────┼─────────────┼───────────┼─────────┼──────┤
│board_atmelsam_sodaq_explorer │ platform_atmelsam │ External │ SAMD21J18A  │ 48MHz     │ 256KB   │ 32KB │
├──────────────────────────────┼───────────────────┼──────────┼─────────────┼───────────┼─────────┼──────┤
│board_atmelavr_sodaq_galora   │ platform_atmelavr │ On-board │ ATMEGA1284P │ 8MHz      │ 127KB   │ 16KB │
└──────────────────────────────┴───────────────────┴──────────┴─────────────┴───────────┴─────────┴──────┘
│board_atmelavr_sodaq_mbili    │ platform_atmelavr │ On-board │ ATMEGA1284P │ 8MHz      │ 127KB   │ 16KB │
├──────────────────────────────┼───────────────────┼──────────┼─────────────┼───────────┼─────────┼──────┤
│board_atmelavr_sodaq_moja     │ platform_atmelavr │ On-board │ ATMEGA328P  │ 8MHz      │ 31.50KB │ 2KB  │
├──────────────────────────────┼───────────────────┼──────────┼─────────────┼───────────┼─────────┼──────┤
│board_atmelavr_sodaq_ndogo    │ platform_atmelavr │ On-board │ ATMEGA1284P │ 8MHz      │ 127KB   │ 16KB │
├──────────────────────────────┼───────────────────┼──────────┼─────────────┼───────────┼─────────┼──────┤
│board_atmelsam_sodaq_one      │ platform_atmelsam │ External │ SAMD21G18A  │ 48MHz     │ 256KB   │ 32KB │
├──────────────────────────────┼───────────────────┼──────────┼─────────────┼───────────┼─────────┼──────┤
│board_atmelsam_sodaq_sara     │ platform_atmelsam │ External │ SAMD21J18A  │ 48MHz     │ 256KB   │ 32KB │
├──────────────────────────────┼───────────────────┼──────────┼─────────────┼───────────┼─────────┼──────┤
│board_atmelsam_sodaq_sff      │ platform_atmelsam │ External │ SAMD21G18A  │ 48MHz     │ 256KB   │ 32KB │
├──────────────────────────────┼───────────────────┼──────────┼─────────────┼───────────┼─────────┼──────┤
│board_atmelavr_sodaq_tatu     │ platform_atmelavr │ On-board │ ATMEGA1284P │ 8MHz      │ 127KB   │ 16KB │
└──────────────────────────────┴───────────────────┴──────────┴─────────────┴───────────┴─────────┴──────┘
SeeedStudio
┌────────────────────────────────┬──────────────────────┬──────────┬───────────────┬───────────┬─────────┬───────┐
│Name                            │ Platform             │ Debug    │ MCU           │ Frequency │ Flash   │ RAM   │
├────────────────────────────────┼──────────────────────┼──────────┼───────────────┼───────────┼─────────┼───────┤
│board_nordicnrf51_seeedArchBLE  │ platform_nordicnrf51 │ On-board │ NRF51822      │ 16MHz     │ 128KB   │ 16KB  │
├────────────────────────────────┼──────────────────────┼──────────┼───────────────┼───────────┼─────────┼───────┤
│board_nordicnrf51_seeedArchLink │ platform_nordicnrf51 │ On-board │ NRF51822      │ 16MHz     │ 256KB   │ 16KB  │
├────────────────────────────────┼──────────────────────┼──────────┼───────────────┼───────────┼─────────┼───────┤
│board_ststm32_seeedArchMax      │ platform_ststm32     │ On-board │ STM32F407VET6 │ 168MHz    │ 512KB   │ 192KB │
├────────────────────────────────┼──────────────────────┼──────────┼───────────────┼───────────┼─────────┼───────┤
│board_nxplpc_seeedArchPro       │ platform_nxplpc      │ On-board │ LPC1768       │ 96MHz     │ 512KB   │ 64KB  │
├────────────────────────────────┼──────────────────────┼──────────┼───────────────┼───────────┼─────────┼───────┤
│board_nordicnrf51_seeedTinyBLE  │ platform_nordicnrf51 │ On-board │ NRF51822      │ 16MHz     │ 256KB   │ 16KB  │
├────────────────────────────────┼──────────────────────┼──────────┼───────────────┼───────────┼─────────┼───────┤
│board_ststm32_wio_3g            │ platform_ststm32     │ On-board │ STM32F439VI   │ 180MHz    │ 2MB     │ 256KB │
├────────────────────────────────┼──────────────────────┼──────────┼───────────────┼───────────┼─────────┼───────┤
│board_atmelavr_seeeduino        │ platform_atmelavr    │ On-board │ ATMEGA328P    │ 16MHz     │ 31.50KB │ 2KB   │
├────────────────────────────────┼──────────────────────┼──────────┼───────────────┼───────────┼─────────┼───────┤
│board_gd32v_wio_lite_risc-v     │ platform_gd32v       │ External │ GD32VF103CBT6 │ 108MHz    │ 128KB   │ 32KB  │
└────────────────────────────────┴──────────────────────┴──────────┴───────────────┴───────────┴─────────┴───────┘
Learn more about cmd_test command.  .SS Tutorials and Examples
Tutorials • tutorial_unit_testing_blink
• ThingForward: Start Embedded Testing with PlatformIO
• ThingForward: Embedded Testing with PlatformIO - Part 2
• ThingForward: Embedded Testing with PlatformIO – Part 3: Remoting
• ThingForward: Embedded Testing with PlatformIO – Part 4: Continuous Integration
• ThingForward, Webinar: Unit Testing for Embedded with PlatformIO and Qt Creator
• Xose Pérez: Automated unit testing in the metal
Project Examples • Embedded: Wiring Blink
• Local & Embedded: Calculator
• PlatformIO Remote Unit Testing Example
For the other examples and source code please follow to PlatformIO Unit Testing Examples repository.
Configuration PIO Unit Testing Engine can be configured from projectconf
Test Types Desktop PIO Unit Testing Engine builds a test program for a host machine using platform_native development platform. This test could be run only with the desktop or ci VM instance.
NOTE: PlatformIO does not install any toolchains automatically for platform_native and requires GCC toolchain to be installed on your host machine.  Please open Terminal and check that the gcc command is installed.
Embedded PIO Unit Testing Engine builds a special firmware for a target device (board) and programs it. Then, it connects to this device using configured Serial projectconf_test_port and communicates via projectconf_test_transport. Finally, it runs tests on the embedded side, collects results, analyzes them, and provides a summary on a host machine side (desktop).
NOTE: Please note that the PIO Unit Testing Engine uses the first available Serial/UART implementation (depending on a projectconf_env_framework) as a communication interface between the PIO Unit Testing Engine and target device. If you use Serial in your project libraries, please wrap/hide Serial-based blocks with #ifndef UNIT_TEST macro.
Also, you can create custom projectconf_test_transport and implement the base interface.
Test Runner Test Runner allows you to process specific environments or ignore a test using "Glob patterns". You can also ignore a test for specific environments using a projectconf_test_ignore option from projectconf.
Local Allows you to run a test on a host machine or on a target device (board), which is directly connected to the host machine. In this case, you need to use the cmd_test command.
Remote Allows you to run test on a remote machine or remote target device (board) without having to depend on OS software, extra software, SSH, VPN or opening network ports. Remote Unit Testing works in pair with pioremote. In this case, you need to use the special command cmd_remote_test.
PlatformIO supports multiple ci systems where you can run unit tests at each integration stage. See real PlatformIO Remote Unit Testing Example.
Test Transport PIO Unit Testing Engine engine uses different transports to communicate with a target device. By default, it uses Serial/UART transport provided by a projectconf_env_framework. For example, when "projectconf_env_framework = arduino", the first available Serial will be used.  When platform_native dev-platform is used a native transport will be activated automatically. See example below.
Default baudrate/speed is set to projectconf_test_speed.
You can also define custom transport and implement its interface:
• unittest_uart_begin();
• unittest_uart_putchar(char c);
• unittest_uart_flush();
• unittest_uart_end();
1. Custom transport for platform_native platform
• Set test_transport = custom in projectconf
[env:mycustomtransport] platform = native test_transport = custom
• Create unittest_transport.h file in project/test directory and implement prototypes above
#ifndef UNITTEST_TRANSPORT_H #define UNITTEST_TRANSPORT_H
void unittest_uart_begin() {
void unittest_uart_putchar(char c) { putchar(c); }
void unittest_uart_flush() { fflush(stdout); }
void unittest_uart_end() {
2. tutorial_stm32cube_debugging_unit_testing
Workflow 1. Create PlatformIO project using the cmd_project_init command. For Desktop Unit Testing (on a host machine), you need to use platform_native.
; ; Embedded platforms ;
[env:nodemcu] platform = espressif8266 framework = arduino board = nodemcuv2
; ; Desktop platforms (Win, Mac, Linux, Raspberry Pi, etc) ; See https://platformio.org/platforms/native ;
[env:native] platform = native
2. Create a test folder in a root of your project. See projectconf_pio_test_dir.
3. Write a test using API. Each test is a small independent program/firmware with its own main() or setup()/loop() functions. Test should start with UNITY_BEGIN() and finish with UNITY_END() calls.
WARNING: If your board does not support software resetting via Serial.DTR/RTS, you should add at least 2 seconds delay before UNITY_BEGIN().  That time is needed to establish a Serial connection between a host machine and a target device.
delay(2000); // for Arduino framework wait(2);     // for ARM mbed framework UNITY_BEGIN();
4. Place a test in the test directory. If you have more than one test, split them into sub-folders. For example, test/test_1/*.[c,cpp,h], test_N/*.[c,cpp,h], etc. If there is no such directory in the test folder, then PIO Unit Testing Engine will treat the source code of test folder as SINGLE test.
5. Run tests using the cmd_test command.
Shared Code PIO Unit Testing Engine does not build source code from projectconf_pio_src_dir folder by default. If you have a shared/common code between your "main" and "test" programs, you have 2 options:
1. RECOMMENDED. We recommend splitting the source code into multiple components and placing them into projectconf_pio_lib_dir (project's private libraries and components). ldf will find and include these libraries automatically in the build process. You can include any library/component header file in your test or program source code via #include <MyComponent.h>.
See Local & Embedded: Calculator  for an example, where we have a "calculator" component in projectconf_pio_lib_dir folder and include it in tests and the main program using #include <calculator.h>.
2. Manually instruct PlatformIO to build source code from projectconf_pio_src_dir folder using projectconf_test_build_project_src option in projectconf:
[env:myenv] platform = ... test_build_project_src = true
This is very useful if you unit test independent libraries where you can't split source code.
WARNING: Please note that you will need to use #ifdef UNIT_TEST and #endif guard to hide non-test related source code. For example, own main() or setup() / loop() functions.
API Summary of the Unity Test API:
• Running Tests
• RUN_TEST(func)
• Ignoring Tests
• TEST_IGNORE()
• TEST_IGNORE_MESSAGE (message)
• Aborting Tests
• TEST_PROTECT()
• TEST_ABORT()
• Basic Validity Tests
• TEST_ASSERT_TRUE(condition)
• TEST_ASSERT_FALSE(condition)
• TEST_ASSERT(condition)
• TEST_ASSERT_UNLESS(condition)
• TEST_FAIL()
• TEST_FAIL_MESSAGE(message)
• Numerical Assertions: Integers
• TEST_ASSERT_EQUAL_INT(expected, actual)
• TEST_ASSERT_EQUAL_INT8(expected, actual)
• TEST_ASSERT_EQUAL_INT16(expected, actual)
• TEST_ASSERT_EQUAL_INT32(expected, actual)
• TEST_ASSERT_EQUAL_INT64(expected, actual)
• TEST_ASSERT_EQUAL_UINT(expected, actual)
• TEST_ASSERT_EQUAL_UINT8(expected, actual)
• TEST_ASSERT_EQUAL_UINT16(expected, actual)
• TEST_ASSERT_EQUAL_UINT32(expected, actual)
• TEST_ASSERT_EQUAL_UINT64(expected, actual)
• TEST_ASSERT_EQUAL_HEX(expected, actual)
• TEST_ASSERT_EQUAL_HEX8(expected, actual)
• TEST_ASSERT_EQUAL_HEX16(expected, actual)
• TEST_ASSERT_EQUAL_HEX32(expected, actual)
• TEST_ASSERT_EQUAL_HEX64(expected, actual)
• TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, elements)
• TEST_ASSERT_EQUAL(expected, actual)
• TEST_ASSERT_INT_WITHIN(delta, expected, actual)
• Numerical Assertions: Bitwise
• TEST_ASSERT_BITS(mask, expected, actual)
• TEST_ASSERT_BITS_HIGH(mask, actual)
• TEST_ASSERT_BITS_LOW(mask, actual)
• TEST_ASSERT_BIT_HIGH(mask, actual)
• TEST_ASSERT_BIT_LOW(mask, actual)
• Numerical Assertions: Floats
• TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual)
• TEST_ASSERT_EQUAL_FLOAT(expected, actual)
• TEST_ASSERT_EQUAL_DOUBLE(expected, actual)
• String Assertions
• TEST_ASSERT_EQUAL_STRING(expected, actual)
• TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len)
• TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message)
• TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message)
• Pointer Assertions
• TEST_ASSERT_NULL(pointer)
• TEST_ASSERT_NOT_NULL(pointer)
• Memory Assertions
• TEST_ASSERT_EQUAL_MEMORY(expected, actual, len)
CLI Guide Cloud & Desktop IDE Native Extensions Native extensions and plugins provide official integration with IDEs/Text Editors and contain built-in piocore and piohome. We highly recommend to use the next native integrations for:
• ide_vscode
• ide_clion (Experimental)
Cloud IDE Cloud9 Cloud9 combines a powerful online code editor with a full Ubuntu workspace in the cloud.  Workspaces are powered by Docker Ubuntu containers that give you full freedom over your environment, including sudo rights. Do a git push, compile SASS, see server output, and Run apps easily with the built-in Terminal and Runners.
Contents • Cloud9
• Integration
• PlatformIO Build System
• Remote Device Manager
• Remote Firmware Uploading
• Multi-Project workspace
1. Please make sure to read pioremote guide first.
2. You need pioaccount if you don't have it. Registration is FREE.
3. You should have a running cmd_remote_agent on a remote machine where hardware devices are connected physically or accessible for the remote operations. See PIO Remote pio_remote_quickstart for details.
Demo .SS Integration
1. Sign in to Cloud9. A registration is FREE and gives you for FREE 1 private workspace (where you can host multiple PlatformIO Projects) and unlimited public workspaces.
2. Create a new workspace using Blank template [image]
3. Install piocore using Cloud IDE Terminal. Paste a next command
sudo python -c "$(curl -fsSL https://raw.githubusercontent.com/platformio/platformio/develop/scripts/get-platformio.py)" [image]
4. Log in to pioaccount using cmd_account_login command.
Quick Start Let's create our first PlatformIO-based Cloud9 Project
1. Initialize new PlatformIO-based Project. Run a next command in Cloud IDE Terminal:
platformio project init --board <ID>
# initialize project for Arduino Uno platformio project init --board uno
To get board ID please use cmd_boards command or Embedded Boards Explorer.
2. Create new source file named main.cpp in src folder using Project Tree (left side). Please make right click on src folder, then "New File" and insert a next content:
void setup() { Serial.begin(9600); Serial.println("Hello Cloud9!"); }
void loop() { /*  serial echo */ while (Serial.available()) { Serial.write(Serial.read()); }
i++; Serial.println(i); delay(100); } [image]
3. If you prefer to work with piocore CLI, then you can process project using Cloud IDE Terminal and the next commands:
• cmd_run - build project locally (using Cloud IDE's virtual machine)
• pio run -t clean - clean project
• pio remote run -t upload - upload firmware (program) to a remote device
• cmd_remote_device_list - list available remote devices
• cmd_remote_device_monitor - Remote Serial Port Monitor
If you are interested in better integration with Cloud9 and GUI, please read guide below where we will explain how to create custom Build System for PlatformIO and own Runners.
PlatformIO Build System Cloud9 allows one to create own build system and use hotkey or command (Menu: Run > Build) to build a project.
Let's create PlatformIO Build System that will be used for C/C++/H/INO/PDE files by default. Please click on Menu: Run > Build System > New Build System and replace all content with the next:
{ "cmd" : ["pio", "run", "-d", "$file"], "info" : "Building $project_path/$file_name", "selector": "^.*\\.(cpp|c|h|hpp|S|ini|ino|pde)$" }
Save new Build System and give a name PIOBuilder. Now, you can select it as default Build System using Menu: Run > Build System > PIOBuilder.
Remote Device Manager Remote Device Manager works in pair with pioremote.  You can list remote devices that are connected to host machine where cmd_remote_agent is started or are visible for it.
Let's create New Run Configuration (shortcut) that will be used for Remote Device Manager.  Please click on Menu: Run > Run Configurations > Manage..., then "Add New Config" and specify the next values:
• First Blank Input: a name of runner. Please set it to "PIO: Remote Devices"
• Command: set to pio remote device list
• Runner: set to "Shell command" [image]
Remote Firmware Uploading Remote Firmware Uploading works in pair with pioremote.  You can deploy firmware (program) to any devices which are visible for cmd_remote_agent.
Let's create New Run Configuration (shortcut) that will be used for Remote Firmware Uploading.  Please click on Menu: Run > Run Configurations > Manage..., then "Add New Config" and specify the next values:
• First Blank Input: a name of runner. Please set it to "PIO: Remote Upload"
• Command: set to pio remote run -t upload
Remote Serial Port Monitor Remote Serial Port Monitor works in pair with pioremote.  You can read or send data to any device that is connected to host machine where cmd_remote_agent is started.  To list active agents please use this command cmd_remote_agent_list.
Let's create New Run Configuration (shortcut) that will be used for Remote Serial Port Monitor.  Please click on Menu: Run > Run Configurations > Manage..., then "Add New Config" and specify the next values:
• First Blank Input: a name of runner. Please set it to "PIO: Remote Serial Monitor"
• Command: set to pio remote device monitor
Multi-Project workspace You can have multiple PlatformIO-based Projects in the same workspace. We recommend a next folders structure:
├── project-A │   ├── lib │   │   └── README │   ├── platformio.ini │   └── src │       └── main.ino └── project-B ├── lib │   └── README ├── platformio.ini └── src ├── main.cpp └── main.h
In this case, you need to create 2 "New Run Configuration" for Remote Firmware Uploading with using the next commands:
• pio remote run --project-dir project-A -t upload for Project-A
• pio remote run -d project-B -t upload for Project-B
See documentation for platformio remote run --project-dir option.
Codeanywhere Codeanywhere is a Cross Platform Cloud IDE and it has all the features of Desktop IDE but with additional features only a cloud application can give you! Codeanywhere is very flexible and you can set up your workflow any way you want it. The elegant development environment will let you focus on building great applications quicker. All the features you will need for any coding task are built into Codeanywhere, making development more productive and fun.
Contents • Codeanywhere
• Run Button
1. Sign in to Codeanywhere. A registration is FREE and gives you unlimited private projects within the one Container.
2. Open Dashboard Projects
3. Create a new Project and open it. In Connection Wizard create new Container:
• Name set to "PlatformIO"
• Stack search for Python stack (not Python3) that is based on Ubuntu OS.
• Click on "Create" button. [image]
4. Open SSH-Terminal tab (right click on Container (PlatformIO) > SSH Terminal) and install piocore using a next command
5. Log in to pioaccount using cmd_account_login command.
Quick Start Let's create our first PlatformIO-based Codeanywhere Project
1. Initialize new PlatformIO-based Project. Run a next command in a Cloud IDE SSH Terminal:
If you do not see created project, please refresh Project Tree using right-click on Container Name (PlatformIO) > Refresh.
2. Create new source file named main.cpp in src folder using Project Tree (left side). Please make right click on src folder, then "Create File" and insert a next content:
void setup() { Serial.begin(9600); Serial.println("Hello Codeanywhere!"); }
3. If you prefer to work with piocore CLI, then you can process project using Cloud IDE SSH Terminal and the next commands:
4. We recommend to hide "Hidden Files". You can do that via Cloud IDE Menu: View > Show Hidden Files.
Run Button Codeanywhere provides a quick "Run Project" button where you can specify own command. Let's add "PlatformIO Build Project" command:
1. Open "Project Config" via right click on Container Name (PlatformIO) > Config
2. Set commands field to
"commands": [ "pio run" ]
3. Save configuration file.
Now, try to click on "Run Project" button. You can assign any PlatformIO command to this button.  [image]
1. Open Cloud IDE SSH Terminal
2. Paste this command
pio remote device list [image]
Remote Firmware Uploading Remote Firmware Uploading works in pair with pioremote.  You can deploy firmware to any devices which are visible for cmd_remote_agent.
pio remote run -t upload [image]
pio remote device monitor [image]
In this case, you need to use -d, --project-dir option for cmd_run or cmd_remote_run commands:
• pio remote run --project-dir project-A -t upload build Project-A
pio remote run --project-dir project-A -t upload remote firmware uploading using Project-A
pio remote run -d project-B -t upload remote firmware (program) uploading using Project-B
Eclipse Che Eclipse Che is an open-source Java based developer workspace server and cloud integrated development environment (IDE) which provides a remote development platform for multi-user purpose. The workspace server comes with a RESTful webservice and provides high flexibility.  It also contains a SDK which can be used to create plug-ins for languages, frameworks or tools.
Contents • Eclipse Che
Integration 1. Sign in to Codenvy (based on Eclipse Che). A registration is FREE and gives you unlimited private projects.
2. Open Workspaces tab
3. Click on "Add Workspace", then switch to "Runtime" tab.
• Stack search for PLATFORMIO
• Click on "Create" button, then "Open". [image]
4. Using opened Terminal, please log in to pioaccount using cmd_account_login command.
Quick Start Let's create our first PlatformIO-based Codenvy Project
1. Click on Menu: Workspace > Create New Project and select platformio-arduino-blink sample. Set "Name" to "Arduino Blink" and press "Create". [image]
2. Now you can use dropdown Commands menu and process project with "run" command [image]
Desktop IDE PlatformIO IDE for Atom PlatformIO IDE is the next-generation integrated development environment for IoT.
Atom is a text editor that's modern, approachable, yet hackable to the core—a tool you can customize to do anything but also use productively without ever touching a config file.  .SS Contents
• I. Atom
• II. Clang for Intelligent Code Completion
• Launch
• Setting Up the Project
• Process Project
• Menu item PlatformIO
• PlatformIO Toolbar
• Building / Uploading / Targets
• Intelligent Code Completion
• Smart Code Linter
• Known issues
• Smart Code Linter is disabled for Arduino files
• Convert Arduino file to C++ manually
• Force Arduino file as C++
• Arch Linux: PlatformIO IDE Terminal issue
• Frequently Asked Questions
• Keep build panel visible
• Automatically save on build
• Jump to Declaration
• Code Formatting
• Uninstall Atom with PlatformIO IDE
• macOS
• Articles / Manuals
• Changelog
Installation NOTE: Please note that you do not need to install piocore separately if you are going to use PlatformIO IDE for Atom. piocore is built into PlatformIO IDE and you will be able to use it within PlatformIO IDE Terminal.
Also, PlatformIO IDE allows one to install piocore Shell Commands (pio, platformio) globally to your system via Menu: PlatformIO > Install Shell Commands.
I. Atom 0.  Download and install GitHub's official Atom text editor. PlatformIO IDE is built on top of it.
1.  Open Atom Package Manager
• Mac OS X, Menu: Atom > Preferences > Install
• Windows, Menu: File > Settings > Install
• Linux, Menu: Edit > Preferences > Install
2. Search for the official platformio-ide package
3. Install PlatformIO IDE. [image]
II. Clang for Intelligent Code Completion PlatformIO IDE uses Clang for the Intelligent Code Completion. To check that clang is available in your system, please open Terminal and run clang --version. If clang is not installed, then install it and restart Atom:
• Mac OS X: Install the latest Xcode along with the latest Command Line Tools (they are installed automatically when you run clang in Terminal for the first time, or manually by running xcode-select --install
• Windows: Download Clang 3.9.1 for Windows.  Please select "Add LLVM to the system PATH" option on the installation step.
• Clang 3.9.1 for Windows (32-bit)
• Clang 3.9.1 for Windows (64-bit) [image]
WARNING: PLEASE DO NOT INSTALL CLANG 4.0. TEMPORARILY, WE SUPPORT ONLY CLANG 3.9.
If you see a Failed to find MSBuild toolsets directory error in the installation console, please ignore it and press any key to close this window. PlatformIO IDE uses only the Clang completion engine, which should work after that without any problems.
• Linux: Using package managers: apt-get install clang or yum install clang.
• Other Systems: Download the latest Clang for the other systems.
WARNING: If some libraries are not visible in PlatformIO IDE for Atom and Code Completion or Code Linting does not work properly, please perform Menu: PlatformIO > Rebuild C/C++ Project Index (Autocomplete, Linter)
Quick Start This tutorial introduces you to the basics of PlatformIO IDE workflow and shows you the creation process for a simple "Blink" example. After finishing, you will have a general understanding of how to work with projects in the IDE.
Launch After installation, launch PlatformIO IDE by opening Atom. Once Atom is opened, the PlatformIO IDE auto installer will continue to install dependent packages and piocore. Please be patient and let the installation complete. Once finished, PlatformIO IDE will ask you to reload the Atom window to apply installed components. Please click on Reload Now. After that, PlatformIO IDE is ready for use. Happy coding!
Setting Up the Project 1. Click on the "PlatformIO Home" button on the PlatformIO Toolbar [image]
2. Click on "New Project", select a board and create a new PlatformIO Project [image]
3. Open the main.cpp file in the src folder and replace its contents with the following:
WARNING: The code below only works with Arduino-based boards. Please visit the PlatformIO Project Examples repository for other pre-configured projects.
// Set LED_BUILTIN if it is not defined by Arduino framework // #define LED_BUILTIN 13
// wait for a second delay(1000); } [image]
Process Project PlatformIO IDE proposes different ways to process the project (build, clean, upload firmware, run other targets) using:
• Building / Uploading / Targets and hotkeys [image]
5. Run Build and you should see a green "success" result in the build panel: [image]
To upload firmware to the board, run Upload.
6. What is more, you can run specific target or process project environment using Menu: PlatformIO > Run other target...  or call targets list from the status bar (bottom, left corner):
And select desired target: .INDENT 0.0
7. To launch the built-in terminal interface, choose Menu: PlatformIO > Terminal or press the corresponding icon in the PlatformIO toolbar:
This provides you fast access to a set of powerful piocore CLI commands: .INDENT
0.0
8. To run the built-in "Serial Monitor", choose Menu: PlatformIO > Serial Monitor or press the corresponding icon in the PlatformIO toolbar:
The monitor has several settings to adjust your connection:
It also allows you to communicate with your board in an easy way: .SS Menu item
PlatformIO
platformio-ide package adds to Atom new menu item named Menu: PlatformIO (after
Menu: Help item).  [image]
PlatformIO Toolbar PlatformIO IDE Toolbar contains quick access buttons for the popular commands.  Each button contains a hint (leave the mouse on it for a moment).  [image]
• PlatformIO: Build
• PlatformIO: Upload
• PlatformIO: Clean
• Run other target (Build environments, unit_testing)
• Toggle build panel
• ||
• Find in Project...
• PIO Terminal
• Serial Monitor
• Atom Settings
Building / Uploading / Targets • cmd-alt-b / ctrl-alt-b / f9 builds project without auto-uploading.
• cmd-alt-u / ctrl-alt-u builds and uploads (if no errors).
• cmd-alt-c / ctrl-alt-c cleans compiled objects.
• cmd-alt-t / ctrl-alt-t / f7 run other targets (Upload using Programmer, Upload SPIFFS image, Update platforms and libraries).
• cmd-alt-g / ctrl-alt-g / f4 cycles through causes of build error.
• cmd-alt-h / ctrl-alt-h / shift-f4 goes to the first build error.
• cmd-alt-v / ctrl-alt-v / f8 toggles the build panel.
• escape terminates build / closes the build window.
More options: Menu: PlatformIO > Settings > Build.
Intelligent Code Completion PlatformIO IDE uses clang for the Intelligent Code Completion.  To install it or check if it is already installed, please follow see the step II. Clang for Intelligent Code Completion from Installation guide.
WARNING: The libraries which are added/installed after the initializing process will not be reflected in the code linter. You need Menu: PlatformIO > Rebuild C/C++ Project Index (Autocomplete, Linter).
Smart Code Linter PlatformIO IDE uses PlatformIO's pre-built GCC toolchains for Smart Code Linter and rapid professional development.  The configuration data are located in .gcc-flags.json. This file will be automatically created and preconfigured when you initialize project using Menu: PlatformIO > Initialize new PlatformIO Project or update existing....
Install Shell Commands Please navigate to PIO Core piocore_install_shell_commands.
Known issues Smart Code Linter is disabled for Arduino files Smart Code Linter is disabled by default for Arduino files (*.ino and .pde) because they  are not valid C/C++ based source files:
1. Missing includes such as #include <Arduino.h>
2. Function declarations are omitted.
There are two solutions:
Convert Arduino file to C++ manually Recommended! See faq_convert_ino_to_cpp.
Force Arduino file as C++ To force Smart Code Linter to use Arduino files as C++ please
1. Open .gcc-flags.json file from the Initialized/Imported project and add -x c++ flag at the beginning of the value of gccDefaultCppFlags field:
{ "execPath": "...", "gccDefaultCFlags": "...", "gccDefaultCppFlags": "-x c++ -fsyntax-only ...", "gccErrorLimit": 15, "gccIncludePaths": "...", "gccSuppressWarnings": false }
2. Perform all steps from Convert Arduino file to C++ manually (without renaming to .cpp).
WARNING: Please do not modify other flags here. They will be removed on a next "Project Rebuild C/C++ Index" stage.  Please use projectconf_build_flags for projectconf instead.
Arch Linux: PlatformIO IDE Terminal issue Please read this article Installing PlatformIO on Arch Linux.
Frequently Asked Questions Keep build panel visible PlatformIO IDE hides build panel on success by default. Nevertheless, you can keep it visible all time. Please follow to Menu: PlatformIO > Settings > Build and set Panel Visibility to Keep Visible.
Key-bindings (toggle panel):
• cmd+alt+v - Mac OS X
• ctrl+alt+v - Windows/Linux
Automatically save on build If you want automatically save all edited files when triggering a build, please follow to Menu: PlatformIO > Settings > Build and check Automatically save on build.
Jump to Declaration Click on a function/include, press F3 and you will be taken directly to the declaration for that function.
Code Formatting You need to install atom-beautify package and C/C++ Uncrustify Code Beautifier.
Uninstall Atom with PlatformIO IDE Here's how to uninstall the PlatformIO IDE for multiple OS.
See piocore_uninstall, if you do not need it in a system.
Windows 1. Uninstall Atom using "Start > Control Panel > Programs and Features > Uninstall"
2. Remove C:\Users\<user name>\.atom folder (settings, packages, etc...)
3. Remove C:\Users\<user name>\AppData\Local\atom folder (application itself)
4. Remove C:\Users\<user name>\AppData\Roaming\Atom folder (cache, etc.)
5. Remove registry records using regedit:
• HKEY_CLASSES_ROOT\Directory\Background\shell
• HKEY_CLASSES_ROOT\Directory\shell
• HKEY_CLASSES_ROOT*\shell
macOS Run these commands in system Terminal
rm -rf ~/.atom rm /usr/local/bin/atom rm /usr/local/bin/apm rm -rf /Applications/Atom.app rm ~/Library/Preferences/com.github.atom.plist rm ~/Library/Application\ Support/com.github.atom.ShipIt rm -rf ~/Library/Application\ Support/Atom rm -rf ~/Library/Saved\ Application\ State/com.github.atom.savedState rm -rf ~/Library/Caches/com.github.atom rm -rf ~/Library/Caches/Atom
Linux Run these commands in system Terminal
rm /usr/local/bin/atom rm /usr/local/bin/apm rm -rf ~/atom rm -rf ~/.atom rm -rf ~/.config/Atom-Shell rm -rf /usr/local/share/atom/
Articles / Manuals • Mar, 31, 2017 - Robin Reiter - A little guide to PlatformIO. As an Arduino developer, you may want to check that out! (video review)
• Dec 13, 2016 - Dr. Patrick Mineault - Multi-Arduino projects with PlatformIO
• Nov 10, 2016 - PiGreek - PlatformIO the new Arduino IDE ?!
• Aug 18, 2016 - Primal Cortex - Installing PlatformIO on Arch Linux
• Jul 26, 2016 - Embedded Systems Laboratory - แนะนำการใช้งาน PlatformIO IDE สำหรับบอร์ด Arduino และ ESP8266 (Get started with PlatformIO IDE for Arduino board and ESP8266, Thai)
• May 30, 2016 - Ron Moerman - IoT Development with PlatformIO
• May 01, 2016 - Pedro Minatel - PlatformIO – Uma alternativa ao Arduino IDE (PlatformIO - An alternative to the Arduino IDE, Portuguese)
• Apr 23, 2016 - Al Williams - Hackaday: Atomic Arduino (and Other) Development
• Apr 16, 2016 - Sathittham Sangthong - [PlatformIO] มาลองเล่น PlatformIO แทน Arduino IDE กัน (Let's play together with PlatformIO IDE [alternative to Arduino IDE], Thai)
• Apr 11, 2016 - Matjaz Trcek - Top 5 Arduino integrated development environments
• Apr 06, 2016 - Aleks - PlatformIO ausprobiert (Tried PlatformIO, German)