platformio/platformio-core
1
0
Fork 1
mirror of https://github.com/platformio/platformio-core.git synced 2025-07-29 17:47:14 +02:00
Code Issues Packages Projects Releases Wiki Activity

Move boards and platforms to separate repos // Issue #479

Browse Source
This commit is contained in:
Ivan Kravets
2016-05-23 22:28:48 +03:00
parent b3d27b42ad
commit 349b159a7b
77 changed files with 0 additions and 10172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

252
platformio/boards/adafruit.json
View File

@ -1,252 +0,0 @@
{
"flora8": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_FLORA8",
"f_cpu": "8000000L",
"mcu": "atmega32u4",
"usb_product": "Adafruit Flora",
"variant": "flora",
"hwid": [
["0x239A", "0x8004"]
]
},
"frameworks": ["arduino"],
"name": "Adafruit Flora",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://www.adafruit.com/product/659",
"vendor": "Adafruit"
},
"bluefruitmicro": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_BLUEFRUITMICRO",
"f_cpu": "8000000L",
"mcu": "atmega32u4",
"usb_product": "Bluefruit Micro",
"variant": "bluefruitmicro",
"hwid": [
["0x239A", "0x800A"]
]
},
"frameworks": ["arduino"],
"name": "Adafruit Bluefruit Micro",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "https://www.adafruit.com/products/2661",
"vendor": "Adafruit"
},
"gemma": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_GEMMA",
"f_cpu": "8000000L",
"mcu": "attiny85",
"variant": "tiny8"
},
"frameworks": ["arduino"],
"name": "Adafruit Gemma",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 512,
"maximum_size": 8192,
"protocol": "usbtiny"
},
"url": "http://www.adafruit.com/products/1222",
"vendor": "Adafruit"
},
"feather32u4": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_FEATHER32U4",
"f_cpu": "8000000L",
"mcu": "atmega32u4",
"usb_product": "Feather 32u4",
"variant": "feather32u4",
"hwid": [
["0x239A", "0x800C"]
]
},
"frameworks": ["arduino"],
"name": "Adafruit Feather",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "https://learn.adafruit.com/adafruit-feather-32u4-bluefruit-le/",
"vendor": "Adafruit"
},
"trinket3": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_TRINKET3",
"f_cpu": "8000000L",
"mcu": "attiny85",
"variant": "tiny8"
},
"frameworks": ["arduino"],
"name": "Adafruit Trinket 3V/8MHz",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 512,
"maximum_size": 8192,
"protocol": "usbtiny"
},
"url": "http://www.adafruit.com/products/1500",
"vendor": "Adafruit"
},
"trinket5": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_TRINKET5",
"f_cpu": "16000000L",
"mcu": "attiny85",
"variant": "tiny8"
},
"frameworks": ["arduino"],
"name": "Adafruit Trinket 5V/16MHz",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 512,
"maximum_size": 8192,
"protocol": "usbtiny"
},
"url": "http://www.adafruit.com/products/1501",
"vendor": "Adafruit"
},
"metro": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_METRO",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "Adafruit Metro",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 32256,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.adafruit.com/products/2466",
"vendor": "Adafruit"
},
"protrinket3": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_PROTRINKET3",
"f_cpu": "12000000L",
"mcu": "atmega328p",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino"],
"name": "Adafruit Pro Trinket 3V/12MHz (USB)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 28672,
"protocol": "usbtiny"
},
"url": "http://www.adafruit.com/products/2010",
"vendor": "Adafruit"
},
"protrinket5": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_PROTRINKET5",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino"],
"name": "Adafruit Pro Trinket 5V/16MHz (USB)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 28672,
"protocol": "usbtiny"
},
"url": "http://www.adafruit.com/products/2000",
"vendor": "Adafruit"
},
"protrinket3ftdi": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_PROTRINKET3FTDI",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino"],
"name": "Adafruit Pro Trinket 3V/12MHz (FTDI)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 28672,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.adafruit.com/products/2010",
"vendor": "Adafruit"
},
"protrinket5ftdi": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_PROTRINKET5FTDI",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino"],
"name": "Adafruit Pro Trinket 5V/16MHz (USB)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 28672,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.adafruit.com/products/2000",
"vendor": "Adafruit"
}
}

927
platformio/boards/arduino.json
View File

@ -1,927 +0,0 @@
{
"LilyPadUSB": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_LILYPAD_USB",
"f_cpu": "8000000L",
"mcu": "atmega32u4",
"usb_product": "LilyPad USB",
"variant": "leonardo",
"hwid": [
["0x1B4F", "0x9207"],
["0x1B4F", "0x9208"]
]
},
"frameworks": ["arduino"],
"name": "Arduino LilyPad USB",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://arduino.cc/en/Main/ArduinoBoardLilyPadUSB",
"vendor": "Arduino"
},
"atmegangatmega168": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_NG",
"f_cpu": "16000000L",
"mcu": "atmega168",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "Arduino NG or older ATmega168",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 14336,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 19200
},
"url": "http://arduino.cc/en/main/boards",
"vendor": "Arduino"
},
"atmegangatmega8": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_NG",
"f_cpu": "16000000L",
"mcu": "atmega8",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "Arduino NG or older ATmega8",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 7168,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 19200
},
"url": "http://arduino.cc/en/main/boards",
"vendor": "Arduino"
},
"btatmega168": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_BT",
"f_cpu": "16000000L",
"mcu": "atmega168",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino"],
"name": "Arduino BT ATmega168",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 1024,
"maximum_size": 14336,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 19200
},
"url": "http://arduino.cc/en/main/boards",
"vendor": "Arduino"
},
"btatmega328": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_BT",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino"],
"name": "Arduino BT ATmega328",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2048,
"maximum_size": 28672,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 19200
},
"url": "http://arduino.cc/en/main/boards",
"vendor": "Arduino"
},
"diecimilaatmega168": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_DUEMILANOVE",
"f_cpu": "16000000L",
"mcu": "atmega168",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "Arduino Duemilanove or Diecimila ATmega168",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 14336,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 19200
},
"url": "http://arduino.cc/en/Main/ArduinoBoardDiecimila",
"vendor": "Arduino"
},
"diecimilaatmega328": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_DUEMILANOVE",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "Arduino Duemilanove or Diecimila ATmega328",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 30720,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "http://arduino.cc/en/Main/ArduinoBoardDiecimila",
"vendor": "Arduino"
},
"esplora": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ESPLORA",
"f_cpu": "16000000L",
"mcu": "atmega32u4",
"usb_product": "Arduino Esplora",
"variant": "leonardo",
"hwid": [
["0x2341", "0x003C"],
["0x2341", "0x803C"],
["0x2A03", "0x003C"],
["0x2A03", "0x803C"]
]
},
"frameworks": ["arduino"],
"name": "Arduino Esplora",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-esplora",
"vendor": "Arduino"
},
"ethernet": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ETHERNET",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "ethernet"
},
"frameworks": ["arduino"],
"name": "Arduino Ethernet",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 32256,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-ethernet",
"vendor": "Arduino"
},
"fio": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_FIO",
"f_cpu": "8000000L",
"mcu": "atmega328p",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino"],
"name": "Arduino Fio",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 30720,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "http://arduino.cc/en/Main/ArduinoBoardFio",
"vendor": "Arduino"
},
"leonardo": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_LEONARDO",
"f_cpu": "16000000L",
"mcu": "atmega32u4",
"usb_product": "Arduino Leonardo",
"variant": "leonardo",
"hwid": [
["0x2341", "0x0036"],
["0x2341", "0x8036"],
["0x2A03", "0x0036"],
["0x2A03", "0x8036"]
]
},
"frameworks": ["arduino"],
"name": "Arduino Leonardo",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-leonardo",
"vendor": "Arduino"
},
"leonardoeth": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_LEONARDO",
"f_cpu": "16000000L",
"mcu": "atmega32u4",
"usb_product": "Arduino Leonardo ETH",
"variant": "leonardo",
"hwid": [
["0x2A03", "0x8040"],
["0x2A03", "0x0040"]
]
},
"frameworks": ["arduino"],
"name": "Arduino Leonardo ETH",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-leonardo-eth",
"vendor": "Arduino"
},
"lilypadatmega168": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_LILYPAD",
"f_cpu": "8000000L",
"mcu": "atmega168",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "Arduino LilyPad ATmega168",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 14336,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 19200
},
"url": "http://arduino.cc/en/Main/ArduinoBoardLilyPad",
"vendor": "Arduino"
},
"lilypadatmega328": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_LILYPAD",
"f_cpu": "8000000L",
"mcu": "atmega328p",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "Arduino LilyPad ATmega328",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 30720,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "http://arduino.cc/en/Main/ArduinoBoardLilyPad",
"vendor": "Arduino"
},
"megaADK": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ADK",
"f_cpu": "16000000L",
"mcu": "atmega2560",
"variant": "mega"
},
"frameworks": ["arduino"],
"name": "Arduino Mega ADK",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 253952,
"protocol": "wiring",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-mega-adk",
"vendor": "Arduino"
},
"megaatmega1280": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_MEGA",
"f_cpu": "16000000L",
"mcu": "atmega1280",
"variant": "mega"
},
"frameworks": ["arduino"],
"name": "Arduino Mega or Mega 2560 ATmega1280",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 126976,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-mega-2560",
"vendor": "Arduino"
},
"megaatmega2560": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_MEGA2560",
"f_cpu": "16000000L",
"mcu": "atmega2560",
"variant": "mega"
},
"frameworks": ["arduino", "simba"],
"name": "Arduino Mega or Mega 2560 ATmega2560 (Mega 2560)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 253952,
"protocol": "wiring",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-mega-2560",
"vendor": "Arduino"
},
"micro": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_MICRO",
"f_cpu": "16000000L",
"mcu": "atmega32u4",
"usb_product": "Arduino Micro",
"variant": "micro",
"hwid": [
["0x2341", "0x0037"],
["0x2341", "0x8037"],
["0x2A03", "0x0037"],
["0x2A03", "0x8037"]
]
},
"frameworks": ["arduino"],
"name": "Arduino Micro",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-micro",
"vendor": "Arduino"
},
"miniatmega168": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_MINI",
"f_cpu": "16000000L",
"mcu": "atmega168",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino"],
"name": "Arduino Mini ATmega168",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 14336,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 19200
},
"url": "http://arduino.cc/en/Main/ArduinoBoardMini",
"vendor": "Arduino"
},
"miniatmega328": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_MINI",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino"],
"name": "Arduino Mini ATmega328",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 28672,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://arduino.cc/en/Main/ArduinoBoardMini",
"vendor": "Arduino"
},
"nanoatmega168": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_NANO",
"f_cpu": "16000000L",
"mcu": "atmega168",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino"],
"name": "Arduino Nano ATmega168",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 14336,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 19200
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-nano",
"vendor": "Arduino"
},
"nanoatmega328": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_NANO",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino", "simba"],
"name": "Arduino Nano ATmega328",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 30720,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-nano",
"vendor": "Arduino"
},
"pro16MHzatmega168": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_PRO",
"f_cpu": "16000000L",
"mcu": "atmega168",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino"],
"name": "Arduino Pro or Pro Mini ATmega168 (5V, 16 MHz)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 14336,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 19200
},
"url": "http://arduino.cc/en/Main/ArduinoBoardProMini",
"vendor": "Arduino"
},
"pro16MHzatmega328": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_PRO",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino"],
"name": "Arduino Pro or Pro Mini ATmega328 (5V, 16 MHz)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 30720,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "http://arduino.cc/en/Main/ArduinoBoardProMini",
"vendor": "Arduino"
},
"pro8MHzatmega168": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_PRO",
"f_cpu": "8000000L",
"mcu": "atmega168",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino"],
"name": "Arduino Pro or Pro Mini ATmega168 (3.3V, 8 MHz)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 14336,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 19200
},
"url": "http://arduino.cc/en/Main/ArduinoBoardProMini",
"vendor": "Arduino"
},
"pro8MHzatmega328": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_PRO",
"f_cpu": "8000000L",
"mcu": "atmega328p",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino"],
"name": "Arduino Pro or Pro Mini ATmega328 (3.3V, 8 MHz)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 30720,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "http://arduino.cc/en/Main/ArduinoBoardProMini",
"vendor": "Arduino"
},
"robotControl": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ROBOT_CONTROL",
"f_cpu": "16000000L",
"mcu": "atmega32u4",
"usb_product": "Robot Control",
"variant": "robot_control",
"hwid": [
["0x2341", "0x0038"],
["0x2341", "0x8038"],
["0x2A03", "0x0038"],
["0x2A03", "0x8038"]
]
},
"frameworks": ["arduino"],
"name": "Arduino Robot Control",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-robot",
"vendor": "Arduino"
},
"robotMotor": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ROBOT_MOTOR",
"f_cpu": "16000000L",
"mcu": "atmega32u4",
"usb_product": "Robot Motor",
"variant": "robot_motor",
"hwid": [
["0x2341", "0x0039"],
["0x2341", "0x8039"],
["0x2A03", "0x0039"],
["0x2A03", "0x8039"]
]
},
"frameworks": ["arduino"],
"name": "Arduino Robot Motor",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-robot",
"vendor": "Arduino"
},
"uno": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_UNO",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "standard",
"hwid": [
["0x2341", "0x0043"],
["0x2341", "0x0001"],
["0x2A03", "0x0043"]
]
},
"frameworks": ["arduino", "simba"],
"name": "Arduino Uno",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 32256,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-uno",
"vendor": "Arduino"
},
"yun": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_YUN",
"f_cpu": "16000000L",
"mcu": "atmega32u4",
"usb_product": "Arduino Yun",
"variant": "yun",
"hwid": [
["0x2341", "0x0041"],
["0x2341", "0x8041"],
["0x2A03", "0x0041"],
["0x2A03", "0x8041"]
]
},
"frameworks": ["arduino"],
"name": "Arduino Yun",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"via_ssh": true,
"wait_for_upload_port": true
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-yun",
"vendor": "Arduino"
},
"yunmini": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_YUN",
"f_cpu": "16000000L",
"mcu": "atmega32u4",
"usb_product": "Arduino Yun Mini",
"variant": "yun",
"hwid": [
["0x2A03", "0x8050"],
["0x2A03", "0x0050"]
]
},
"frameworks": ["arduino"],
"name": "Arduino Yun Mini",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"via_ssh": true,
"wait_for_upload_port": true
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-yun-mini",
"vendor": "Arduino"
},
"chiwawa": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_YUN",
"f_cpu": "16000000L",
"mcu": "atmega32u4",
"usb_product": "Arduino Industrial 101",
"variant": "yun",
"hwid": [
["0x2A03", "0x8056"],
["0x2A03", "0x0056"]
]
},
"frameworks": ["arduino"],
"name": "Arduino Industrial 101",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"via_ssh": true,
"wait_for_upload_port": true
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-industrial-101",
"vendor": "Arduino"
},
"one": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_YUN",
"f_cpu": "16000000L",
"mcu": "atmega32u4",
"usb_product": "Linino One",
"variant": "yun",
"hwid": [
["0x2A03", "0x8001"],
["0x2A03", "0x0001"]
]
},
"frameworks": ["arduino"],
"name": "Linino One",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"via_ssh": true,
"wait_for_upload_port": true
},
"url": "http://www.linino.org/portfolio/linino-one/",
"vendor": "Linino"
},
"due": {
"build": {
"core": "arduino",
"extra_flags": "-D__SAM3X8E__ -DARDUINO_SAM_DUE -DARDUINO_ARCH_SAM",
"f_cpu": "84000000L",
"mcu": "sam3x8e",
"cpu": "cortex-m3",
"usb_product": "Arduino Due",
"variant": "arduino_due_x",
"ldscript": "sam3x8e.ld",
"hwid": [
["0x2341", "0x003D"],
["0x2A03", "0x003D"]
]
},
"frameworks": ["arduino", "simba"],
"name": "Arduino Due (Programming Port)",
"platform": "atmelsam",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 32768,
"maximum_size": 524288,
"protocol": "sam-ba",
"require_upload_port" : true,
"use_1200bps_touch": true,
"wait_for_upload_port": false
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-due",
"vendor": "Arduino"
},
"dueUSB": {
"build": {
"core": "arduino",
"extra_flags": "-D__SAM3X8E__ -DARDUINO_SAM_DUE -DARDUINO_ARCH_SAM",
"f_cpu": "84000000L",
"mcu": "sam3x8e",
"cpu": "cortex-m3",
"usb_product": "Arduino Due",
"variant": "arduino_due_x",
"ldscript": "sam3x8e.ld",
"hwid": [
["0x2341", "0x003E"],
["0x2A03", "0x003E"]
]
},
"frameworks": ["arduino"],
"name": "Arduino Due (USB Native Port)",
"platform": "atmelsam",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 32768,
"maximum_size": 524288,
"protocol": "sam-ba",
"require_upload_port" : true,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://www.arduino.org/products/boards/4-arduino-boards/arduino-due",
"vendor": "Arduino"
},
"zero": {
"build": {
"core": "arduino_zero",
"extra_flags": "-DARDUINO_SAMD_ZERO -DARDUINO_ARCH_SAMD -D__SAMD21G18A__",
"f_cpu": "48000000L",
"mcu": "samd21g18a",
"cpu": "cortex-m0plus",
"usb_product": "Arduino Zero",
"variant": "arduino_zero",
"ldscript": "flash_with_bootloader.ld",
"hwid": [
["0x2341", "0x804D"],
["0x03EB", "0x2157"]
]
},
"frameworks": ["arduino"],
"name": "Arduino Zero (Programming Port)",
"platform": "atmelsam",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 32768,
"maximum_size": 262144,
"protocol": "sam-ba",
"require_upload_port" : false,
"use_1200bps_touch": false,
"wait_for_upload_port": false
},
"url": "https://www.arduino.cc/en/Main/ArduinoBoardZero",
"vendor": "Arduino"
},
"zeroUSB": {
"build": {
"core": "arduino_zero",
"extra_flags": "-DARDUINO_SAMD_ZERO -DARDUINO_ARCH_SAMD -D__SAMD21G18A__",
"f_cpu": "48000000L",
"mcu": "samd21g18a",
"cpu": "cortex-m0plus",
"usb_product": "Arduino Zero",
"variant": "arduino_zero",
"ldscript": "flash_with_bootloader.ld",
"hwid": [
["0x2341", "0x804D"],
["0x2341", "0x004D"],
["0x2341", "0x824D"]
]
},
"frameworks": ["arduino"],
"name": "Arduino Zero (USB Native Port)",
"platform": "atmelsam",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 32768,
"maximum_size": 262144,
"protocol": "sam-ba",
"require_upload_port" : true,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "https://www.arduino.cc/en/Main/ArduinoBoardZero",
"vendor": "Arduino"
}
}

50
platformio/boards/atmelsam.json
View File

@ -1,50 +0,0 @@
{
"samr21_xpro": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0plus",
"mcu": "atsamr21g18a"
},
"frameworks": ["mbed"],
"name": "Atmel ATSAMR21-XPRO",
"platform": "atmelsam",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/SAMR21-XPRO/",
"vendor": "Atmel"
},
"saml21_xpro_b": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0plus",
"mcu": "atsaml21j18b"
},
"frameworks": ["mbed"],
"name": "Atmel SAML21-XPRO-B",
"platform": "atmelsam",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/SAML21-XPRO/",
"vendor": "Atmel"
},
"samd21_xpro": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0plus",
"mcu": "atsamd21j18a"
},
"frameworks": ["mbed"],
"name": "Atmel SAMD21-XPRO",
"platform": "atmelsam",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/SAMD21-XPRO/",
"vendor": "Atmel"
}
}

107
platformio/boards/digistump.json
View File

@ -1,107 +0,0 @@
{
"digispark-tiny": {
"build": {
"core": "digispark_tiny",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_DIGISPARK",
"f_cpu": "16000000L",
"mcu": "attiny85",
"variant": "digispark_tiny"
},
"frameworks": ["arduino"],
"name": "Digistump Digispark (Default - 16 MHz)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 512,
"maximum_size": 6012,
"protocol": "digispark"
},
"url": "http://digistump.com/products/1",
"vendor": "Digistump"
},
"digispark-pro": {
"build": {
"core": "digispark_pro",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_DIGISPARKPRO",
"f_cpu": "16000000L",
"mcu": "attiny167",
"variant": "digispark_pro"
},
"frameworks": ["arduino"],
"name": "Digistump Digispark Pro (Default 16 MHz)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 512,
"maximum_size": 14844,
"protocol": "digispark"
},
"url": "http://digistump.com/products/109",
"vendor": "Digistump"
},
"digispark-pro32": {
"build": {
"core": "digispark_pro",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_DIGISPARKPRO",
"f_cpu": "16000000L",
"mcu": "attiny167",
"variant": "digispark_pro32"
},
"frameworks": ["arduino"],
"name": "Digistump Digispark Pro (16 MHz) (32 byte buffer)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 512,
"maximum_size": 14844,
"protocol": "digispark"
},
"url": "http://digistump.com/products/109",
"vendor": "Digistump"
},
"digispark-pro64": {
"build": {
"core": "digispark_pro",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_DIGISPARKPRO",
"f_cpu": "16000000L",
"mcu": "attiny167",
"variant": "digispark_pro64"
},
"frameworks": ["arduino"],
"name": "Digistump Digispark Pro (16 MHz) (64 byte buffer)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 512,
"maximum_size": 14844,
"protocol": "digispark"
},
"url": "http://digistump.com/products/109",
"vendor": "Digistump"
},
"digix": {
"build": {
"core": "digispark_digix",
"extra_flags": "-w -D__SAM3X8E__ -DARDUINO_SAM_DIGIX -DARDUINO_ARCH_SAM",
"f_cpu": "84000000L",
"mcu": "at91sam3x8e",
"cpu": "cortex-m3",
"ldscript": "sam3x8e.ld",
"usb_product": "Digistump DigiX",
"variant": "digispark_digix",
"hwid": [
["0x16D0", "0x078A"]
]
},
"frameworks": ["arduino"],
"name": "Digistump DigiX",
"platform": "atmelsam",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 28672,
"maximum_size": 524288,
"protocol": "sam-ba",
"require_upload_port" : true,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://digistump.com/products/50",
"vendor": "Digistump"
}
}

86
platformio/boards/engduino.json
View File

@ -1,86 +0,0 @@
{
"engduinov1": {
"build": {
"board": "AVR_ENGDUINOV1",
"core": "arduino",
"f_cpu": "8000000L",
"mcu": "atmega32u4",
"usb_product": "EngduinoV1",
"variant": "engduinov1",
"hwid": [
["0x1B4F", "0x9208"]
]
},
"frameworks": ["arduino"],
"name": "Engduino 1",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://www.engduino.org",
"vendor": "Engduino"
},
"engduinov2": {
"build": {
"board": "AVR_ENGDUINOV2",
"core": "arduino",
"f_cpu": "8000000L",
"mcu": "atmega32u4",
"usb_product": "EngduinoV2",
"variant": "engduinov2",
"hwid": [
["0x1B4F", "0x9208"]
]
},
"frameworks": ["arduino"],
"name": "Engduino 2",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://www.engduino.org",
"vendor": "Engduino"
},
"engduinov3": {
"build": {
"board": "AVR_ENGDUINOV3",
"core": "arduino",
"f_cpu": "8000000L",
"mcu": "atmega32u4",
"usb_product": "EngduinoV3",
"variant": "engduinov3",
"hwid": [
["0x1B4F", "0x9208"]
]
},
"frameworks": ["arduino"],
"name": "Engduino 3",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://www.engduino.org",
"vendor": "Engduino"
}
}

476
platformio/boards/espressif.json
View File

@ -1,476 +0,0 @@
{
"esp01": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_ESP01",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "qio",
"ldscript": "esp8266.flash.512k64.ld",
"mcu": "esp8266",
"variant": "generic"
},
"frameworks": ["arduino", "simba"],
"name": "Espressif Generic ESP8266 ESP-01 512k",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 524288,
"resetmethod": "ck",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.esp8266.com/wiki/doku.php?id=esp8266-module-family",
"vendor": "Espressif"
},
"esp01_1m": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_ESP01",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "qio",
"ldscript": "esp8266.flash.1m256.ld",
"mcu": "esp8266",
"variant": "generic"
},
"frameworks": ["arduino", "simba"],
"name": "Espressif Generic ESP8266 ESP-01 1M",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 1048576,
"resetmethod": "ck",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.esp8266.com/wiki/doku.php?id=esp8266-module-family",
"vendor": "Espressif"
},
"esp07": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_ESP07",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "qio",
"ldscript": "esp8266.flash.4m1m.ld",
"mcu": "esp8266",
"variant": "nodemcu"
},
"frameworks": ["arduino"],
"name": "Espressif Generic ESP8266 ESP-07",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 4194304,
"resetmethod": "nodemcu",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.esp8266.com/wiki/doku.php?id=esp8266-module-family#esp-07",
"vendor": "Espressif"
},
"esp12e": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_ESP12",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "dio",
"ldscript": "esp8266.flash.4m1m.ld",
"mcu": "esp8266",
"variant": "nodemcu"
},
"frameworks": ["arduino", "simba"],
"name": "Espressif ESP8266 ESP-12E",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 4194304,
"resetmethod": "nodemcu",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.esp8266.com/wiki/doku.php?id=esp8266-module-family",
"vendor": "Espressif"
},
"espduino": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_ESP13",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "dio",
"ldscript": "esp8266.flash.4m1m.ld",
"mcu": "esp8266",
"variant": "ESPDuino"
},
"frameworks": ["arduino"],
"name": "ESPDuino (ESP-13 Module)",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 4194304,
"resetmethod": "ck",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.tindie.com/products/doit/espduinowifi-uno-r3/",
"vendor": "Doit"
},
"nodemcu": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_NODEMCU",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "qio",
"ldscript": "esp8266.flash.4m1m.ld",
"mcu": "esp8266",
"variant": "nodemcu"
},
"frameworks": ["arduino", "simba"],
"name": "NodeMCU 0.9 (ESP-12 Module)",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 4194304,
"resetmethod": "nodemcu",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.nodemcu.com/",
"vendor": "NodeMCU"
},
"nodemcuv2": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_NODEMCU",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "dio",
"ldscript": "esp8266.flash.4m1m.ld",
"mcu": "esp8266",
"variant": "nodemcu"
},
"frameworks": ["arduino", "simba"],
"name": "NodeMCU 1.0 (ESP-12E Module)",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 4194304,
"resetmethod": "nodemcu",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.nodemcu.com/",
"vendor": "NodeMCU"
},
"huzzah": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_ESP12",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "qio",
"ldscript": "esp8266.flash.4m1m.ld",
"mcu": "esp8266",
"variant": "adafruit"
},
"frameworks": ["arduino", "simba"],
"name": "Adafruit HUZZAH ESP8266",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 4194304,
"resetmethod": "nodemcu",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.adafruit.com/products/2471",
"vendor": "Adafruit"
},
"espresso_lite_v1": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_ESPRESSO_LITE_V1",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "dio",
"ldscript": "esp8266.flash.4m1m.ld",
"mcu": "esp8266",
"variant": "espresso_lite_v1"
},
"frameworks": ["arduino"],
"name": "ESPresso Lite 1.0",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 4194304,
"resetmethod": "nodemcu",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.espert.co",
"vendor": "ESPert"
},
"espresso_lite_v2": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_ESPRESSO_LITE_V2",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "dio",
"ldscript": "esp8266.flash.4m1m.ld",
"mcu": "esp8266",
"variant": "espresso_lite_v2"
},
"frameworks": ["arduino"],
"name": "ESPresso Lite 2.0",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 4194304,
"resetmethod": "ck",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.espert.co",
"vendor": "ESPert"
},
"modwifi": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_MOD_WIFI_ESP8266",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "qio",
"ldscript": "esp8266.flash.2m.ld",
"mcu": "esp8266",
"variant": "generic"
},
"frameworks": ["arduino"],
"name": "Olimex MOD-WIFI-ESP8266(-DEV)",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 2097152,
"resetmethod": "ck",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.olimex.com/Products/IoT/MOD-WIFI-ESP8266-DEV/open-source-hardware",
"vendor": "Olimex"
},
"thing": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_THING",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "qio",
"ldscript": "esp8266.flash.512k64.ld",
"mcu": "esp8266",
"variant": "thing"
},
"frameworks": ["arduino"],
"name": "SparkFun ESP8266 Thing",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 524288,
"resetmethod": "ck",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.sparkfun.com/products/13231",
"vendor": "SparkFun"
},
"thingdev": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_THING",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "dio",
"ldscript": "esp8266.flash.512k64.ld",
"mcu": "esp8266",
"variant": "thing"
},
"frameworks": ["arduino"],
"name": "SparkFun ESP8266 Thing Dev",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 524288,
"resetmethod": "nodemcu",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.sparkfun.com/products/13231",
"vendor": "SparkFun"
},
"esp210": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_ESP210",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "qio",
"ldscript": "esp8266.flash.4m1m.ld",
"mcu": "esp8266",
"variant": "generic"
},
"frameworks": ["arduino"],
"name": "SweetPea ESP-210",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 4194304,
"resetmethod": "ck",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://wiki.sweetpeas.se/index.php?title=ESP-210",
"vendor": "SweetPea"
},
"d1": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_NODEMCU",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "dio",
"ldscript": "esp8266.flash.4m1m.ld",
"mcu": "esp8266",
"variant": "d1"
},
"frameworks": ["arduino"],
"name": "WeMos D1(Retired)",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 4194304,
"resetmethod": "nodemcu",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.wemos.cc/wiki/doku.php?id=en:d1",
"vendor": "WeMos"
},
"d1_mini": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_NODEMCU",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "dio",
"ldscript": "esp8266.flash.4m1m.ld",
"mcu": "esp8266",
"variant": "d1_mini"
},
"frameworks": ["arduino"],
"name": "WeMos D1 R2 & mini",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 4194304,
"resetmethod": "nodemcu",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.wemos.cc/wiki/doku.php?id=en:d1_mini",
"vendor": "WeMos"
},
"espino": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_ESP12",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "qio",
"ldscript": "esp8266.flash.4m1m.ld",
"mcu": "esp8266",
"variant": "espino"
},
"frameworks": ["arduino"],
"name": "ESPino",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 4194304,
"resetmethod": "ck",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.espino.io",
"vendor": "ESPino"
},
"espinotee": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_ESP13",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "qio",
"ldscript": "esp8266.flash.4m1m.ld",
"mcu": "esp8266",
"variant": "espinotee"
},
"frameworks": ["arduino"],
"name": "ThaiEasyElec ESPino",
"platform": "espressif",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 4194304,
"resetmethod": "nodemcu",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.thaieasyelec.com/products/wireless-modules/wifi-modules/espino-wifi-development-board-detail.html",
"vendor": "ThaiEasyElec"
},
"esp_wroom_02": {
"build": {
"core": "esp8266",
"extra_flags": "-DESP8266 -DARDUINO_ARCH_ESP8266 -DARDUINO_ESP8266_ESP_WROOM_02",
"f_cpu": "80000000L",
"f_flash": "40000000L",
"flash_mode": "qio",
"ldscript": "esp8266.flash.4m1m.ld",
"mcu": "esp8266",
"variant": "nodemcu"
},
"frameworks": ["arduino"],
"name": "ESP-WROOM-02",
"platform": "espressif",
"upload": {
"maximum_ram_size": 51200,
"maximum_size": 4194304,
"resetmethod": "nodemcu",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://www.esp8266.com/wiki/doku.php?id=esp8266-module-family",
"vendor": "Espressif"
}
}

114
platformio/boards/freescalekinetis.json
View File

@ -1,114 +0,0 @@
{
"frdm_kl25z": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0plus",
"mcu": "mkl25z128vlk4"
},
"frameworks": ["mbed"],
"name": "Freescale Kinetis FRDM-KL25Z",
"platform": "freescalekinetis",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 131072
},
"url": "https://developer.mbed.org/platforms/KL25Z/",
"vendor": "Freescale"
},
"frdm_kl46z": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0plus",
"mcu": "mkl46z256vll4"
},
"frameworks": ["mbed"],
"name": "Freescale Kinetis FRDM-KL46Z",
"platform": "freescalekinetis",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/FRDM-KL46Z/",
"vendor": "Freescale"
},
"frdm_k64f": {
"build": {
"f_cpu": "120000000L",
"cpu": "cortex-m4",
"mcu": "mk64fn1m0vll12"
},
"frameworks": ["mbed"],
"name": "Freescale Kinetis FRDM-K64F",
"platform": "freescalekinetis",
"upload": {
"maximum_ram_size": 262144,
"maximum_size": 1048576
},
"url": "https://developer.mbed.org/platforms/FRDM-K64F/",
"vendor": "Freescale"
},
"frdm_kl05z": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0plus",
"mcu": "mkl05z32vfm4"
},
"frameworks": ["mbed"],
"name": "Freescale Kinetis FRDM-KL05Z",
"platform": "freescalekinetis",
"upload": {
"maximum_ram_size": 4096,
"maximum_size": 32768
},
"url": "https://developer.mbed.org/platforms/FRDM-KL05Z/",
"vendor": "Freescale"
},
"frdm_k20d50m": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m4",
"mcu": "mk20dx128vlh5"
},
"frameworks": ["mbed"],
"name": "Freescale Kinetis FRDM-K20D50M",
"platform": "freescalekinetis",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 131072
},
"url": "https://developer.mbed.org/platforms/FRDM-K20D50M/",
"vendor": "Freescale"
},
"frdm_k22f": {
"build": {
"f_cpu": "120000000L",
"cpu": "cortex-m4",
"mcu": "mk22fn512vlh12"
},
"frameworks": ["mbed"],
"name": "Freescale Kinetis FRDM-K22F",
"platform": "freescalekinetis",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 524288
},
"url": "https://developer.mbed.org/platforms/FRDM-K22F/",
"vendor": "Freescale"
},
"IBMEthernetKit": {
"build": {
"f_cpu": "120000000L",
"cpu": "cortex-m4",
"mcu": "mk64fn1m0vll12"
},
"frameworks": ["mbed"],
"name": "Ethernet IoT Starter Kit",
"platform": "freescalekinetis",
"upload": {
"maximum_ram_size": 262144,
"maximum_size": 1048576
},
"url": "http://developer.mbed.org/platforms/IBMEthernetKit/",
"vendor": "Freescale"
}
}

30
platformio/boards/intel.json
View File

@ -1,30 +0,0 @@
{
"genuino101": {
"build": {
"core": "arc32",
"extra_flags": "-DARDUINO_ARCH_ARC32 -D__ARDUINO_ARC__",
"f_cpu": "32000000L",
"ldscript": "flash.ld",
"mcu": "ARCv2EM",
"usb_product": "Genuino 101",
"variant": "arduino_101",
"hwid": [
["0x8087", "0x0AB6"]
]
},
"frameworks": ["arduino"],
"name": "Arduino/Genuino 101",
"platform": "intel_arc32",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 196608,
"use_1200bps_touch": true,
"protocol": "script",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": false
},
"url": "https://www.arduino.cc/en/Main/ArduinoBoard101",
"vendor": "Intel"
}
}

45
platformio/boards/lattice.json
View File

@ -1,45 +0,0 @@
{
"icestick": {
"build": {
"core": "icestick",
"f_cpu": "12000000L",
"cpu": "fpga",
"mcu": "ice40hx1k",
"variant": "1k",
"hwid": [
["0x0403", "0x6010"]
]
},
"frameworks": ["icestorm"],
"name": "Lattice iCEstick FPGA Evaluation Kit",
"platform": "lattice_ice40",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 32768
},
"url": "http://www.latticesemi.com/icestick",
"vendor": "Lattice"
},
"icezum": {
"build": {
"core": "icezum",
"f_cpu": "12000000L",
"cpu": "fpga",
"mcu": "ice40hx1k",
"variant": "1k",
"hwid": [
["0x0403", "0x6010"]
]
},
"frameworks": ["icestorm"],
"name": "BQ IceZUM Alhambra FPGA",
"platform": "lattice_ice40",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 32768
},
"url": "https://github.com/bqlabs/icezum/wiki",
"vendor": "BQ"
}
}

577
platformio/boards/microchippic32.json
View File

@ -1,577 +0,0 @@
{
"cerebot32mx4": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_CEREBOT_32MX4_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX460F512.ld",
"mcu": "32MX460F512L",
"variant": "Cerebot_32MX4"
},
"frameworks": ["arduino"],
"name": "Digilent Cerebot 32MX4",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 520192,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://store.digilentinc.com/cerebot-32mx4-limited-time-see-chipkit-pro-mx4/",
"vendor": "Digilent"
},
"cerebot32mx7": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_CEREBOT_32MX7_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX795F512.ld",
"mcu": "32MX795F512L",
"variant": "Cerebot_32MX7"
},
"frameworks": ["arduino"],
"name": "Digilent Cerebot 32MX7",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 520192,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://www.microchip.com/Developmenttools/ProductDetails.aspx?PartNO=TDGL004",
"vendor": "Digilent"
},
"chipkit_mx3": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_CEREBOT_MX3CK_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX320F128.ld",
"mcu": "32MX320F128H",
"variant": "Cerebot_MX3cK"
},
"frameworks": ["arduino"],
"name": "Digilent chipKIT MX3",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 126976,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://store.digilentinc.com/chipkit-mx3-microcontroller-board-with-pmod-headers/",
"vendor": "Digilent"
},
"chipkit_pro_mx4": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_CEREBOT_MX4CK_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX460F512.ld",
"mcu": "32MX460F512L",
"variant": "Cerebot_MX4cK"
},
"frameworks": ["arduino"],
"name": "Digilent chipKIT Pro MX4",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 520192,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://store.digilentinc.com/chipkit-pro-mx4-embedded-systems-trainer-board/",
"vendor": "Digilent"
},
"chipkit_pro_mx7": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_CEREBOT_MX7CK_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX795F512.ld",
"mcu": "32MX795F512L",
"variant": "Cerebot_MX7cK"
},
"frameworks": ["arduino"],
"name": "Digilent chipKIT Pro MX7",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 520192,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://store.digilentinc.com/chipkit-pro-mx7-advanced-peripherals-embedded-systems-trainer-board/",
"vendor": "Digilent"
},
"chipkit_pi": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_CHIPKIT_PI_",
"f_cpu": "40000000L",
"ldscript": "cchipKIT-application-32MX250F128.ld",
"mcu": "32MX250F128B",
"variant": "ChipKIT_Pi"
},
"frameworks": ["arduino"],
"name": "Element14 chipKIT Pi",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 122880,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://www.element14.com/community/community/knode/dev_platforms_kits/element14_dev_kits/microchip-chipkit/chipkit_pi",
"vendor": "element14"
},
"chipkit_cmod": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_CMOD_",
"f_cpu": "40000000L",
"ldscript": "chipKIT-application-32MX150F128.ld",
"mcu": "32MX150F128D",
"variant": "Cmod"
},
"frameworks": ["arduino"],
"name": "Digilent chipKIT Cmod",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 126976,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://store.digilentinc.com/chipkit-cmod-breadboardable-mz-microcontroller-board/",
"vendor": "Digilent"
},
"cui32stem": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_CUI32_ -D_USE_USB_FOR_SERIAL_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX795F512.ld",
"mcu": "32MX795F512H",
"variant": "CUI32stem"
},
"frameworks": ["arduino"],
"name": "SeeedStudio CUI32stem",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 520192,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://www.seeedstudio.com/wiki/CUI32Stem",
"vendor": "SeeedStudio"
},
"ubw32_mx460": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_UBW32_MX460_ -D_USE_USB_FOR_SERIAL_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX460F512.ld",
"mcu": "32MX460F512L",
"variant": "Default_100"
},
"frameworks": ["arduino"],
"name": "UBW32 MX460",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 520192,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://www.schmalzhaus.com/UBW32/",
"vendor": "UBW32"
},
"ubw32_mx795": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_UBW32_MX795_ -D_USE_USB_FOR_SERIAL_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX795F512.ld",
"mcu": "32MX795F512L",
"variant": "Default_100"
},
"frameworks": ["arduino"],
"name": "UBW32 MX795",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 520192,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://www.schmalzhaus.com/UBW32/",
"vendor": "UBW32"
},
"usbono_pic32": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_PONTECH_UAV100_ -D_USE_USB_FOR_SERIAL_ -Danything=1",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX440F512.ld",
"mcu": "32MX440F512H",
"variant": "Default_64"
},
"frameworks": ["arduino"],
"name": "PONTECH UAV100",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 520192,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://www.pontech.com/productdisplay/uav100",
"vendor": "PONTECH"
},
"chipkit_dp32": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_DP32_ -D_USE_USB_FOR_SERIAL_",
"f_cpu": "40000000L",
"ldscript": "chipKIT-application-32MX250F128.ld",
"mcu": "32MX250F128B",
"variant": "DP32"
},
"frameworks": ["arduino"],
"name": "Digilent chipKIT DP32",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 122880,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://store.digilentinc.com/chipkit-dp32-dip-package-prototyping-microcontroller-board/",
"vendor": "Digilent"
},
"fubarino_mini": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_FUBARINO_MINI_ -D_USE_USB_FOR_SERIAL_",
"f_cpu": "48000000L",
"ldscript": "chipKIT-application-32MX250F128.ld",
"mcu": "32MX250F128D",
"variant": "Fubarino_Mini"
},
"frameworks": ["arduino"],
"name": "Fubarino Mini",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 122880,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://fubarino.org/mini/",
"vendor": "Fubarino"
},
"fubarino_sd": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_FUBARINO_SD_ -D_USE_USB_FOR_SERIAL_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX795F512.ld",
"mcu": "32MX795F512H",
"variant": "Fubarino_SD"
},
"frameworks": ["arduino"],
"name": "Fubarino SD (1.5)",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 520192,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://fubarino.org/sd/index.html",
"vendor": "Fubarino"
},
"mega_pic32": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_MEGA_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX795F512.ld",
"mcu": "32MX795F512L",
"variant": "Max32"
},
"frameworks": ["arduino"],
"name": "Digilent chipKIT MAX32",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 520192,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://store.digilentinc.com/chipkit-max32-microcontroller-board-with-mega-r3-headers/",
"vendor": "Digilent"
},
"pinguino32": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_OLIMEX_PIC32_PINGUINO_ -D_USE_USB_FOR_SERIAL_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX440F256.ld",
"mcu": "32MX440F256H",
"variant": "Olimex_PIC32_Pinguino"
},
"frameworks": ["arduino"],
"name": "Olimex PIC32-PINGUINO",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 258048,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "https://www.olimex.com/Products/Duino/PIC32/PIC32-PINGUINO/open-source-hardware",
"vendor": "Olimex"
},
"picadillo_35t": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_PICADILLO_35T_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX795F512.ld",
"mcu": "32MX795F512L",
"variant": "picadillo_35t"
},
"frameworks": ["arduino"],
"name": "4DSystems PICadillo 35T",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 520192,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://www.4dsystems.com.au/product/Picadillo_35T/",
"vendor": "4DSystems"
},
"quick240_usb": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_PONTECH_QUICK240_USB_ -D_USE_USB_FOR_SERIAL_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX795F512.ld",
"mcu": "32MX795F512L",
"variant": "quicK240"
},
"frameworks": ["arduino"],
"name": "PONTECH quicK240",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 520192,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://quick240.com/quicki/",
"vendor": "PONTECH"
},
"chipkit_uc32": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_UC32_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX340F512.ld",
"mcu": "32MX340F512H",
"variant": "uC32"
},
"frameworks": ["arduino"],
"name": "Digilent chipKIT uC32",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 520192,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://store.digilentinc.com/chipkit-uc32-basic-microcontroller-board-with-uno-r3-headers/",
"vendor": "Digilent"
},
"uno_pic32": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_UNO_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX320F128.ld",
"mcu": "32MX320F128H",
"variant": "Uno32"
},
"frameworks": ["arduino"],
"name": "Digilent chipKIT UNO32",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 126976,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://store.digilentinc.com/chipkit-uno32-basic-microcontroller-board-retired-see-chipkit-uc32/",
"vendor": "Digilent"
},
"chipkit_wf32": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_WF32_",
"f_cpu": "80000000L",
"ldscript": "chipKIT-application-32MX695F512.ld",
"mcu": "32MX695F512L",
"variant": "WF32"
},
"frameworks": ["arduino"],
"name": "Digilent chipKIT WF32",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 520192,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://store.digilentinc.com/chipkit-wf32-wifi-enabled-microntroller-board-with-uno-r3-headers/",
"vendor": "Digilent"
},
"chipkit_wifire": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_WIFIRE_",
"f_cpu": "200000000L",
"ldscript": "MZ-application-32MZ2048ECX.ld",
"mcu": "32MZ2048ECG100",
"variant": "WiFire"
},
"frameworks": ["arduino"],
"name": "Digilent chipKIT WiFire",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 524288,
"maximum_size": 2080768,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://store.digilentinc.com/chipkit-wi-fire-wifi-enabled-mz-microcontroller-board/",
"vendor": "Digilent"
},
"openscope": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_OPENSCOPE_",
"f_cpu": "200000000L",
"ldscript": "MZ-application-32MZ2048ECX.ld",
"mcu": "32MZ2048EFG124",
"variant": "OpenScope"
},
"frameworks": ["arduino"],
"name": "Digilent OpenScope",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 524288,
"maximum_size": 2080768,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://store.digilentinc.com/",
"vendor": "Digilent"
},
"openbci": {
"build": {
"core": "pic32",
"extra_flags": "-D_BOARD_DP32_ -D_USE_USB_FOR_SERIAL_",
"f_cpu": "40000000L",
"ldscript": "chipKIT-application-32MX250F128.ld",
"mcu": "32MX250F128B",
"variant": "OpenBCI"
},
"frameworks": ["arduino"],
"name": "OpenBCI 32bit",
"platform": "microchippic32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 122880,
"protocol": "stk500v2",
"require_upload_port" : true,
"speed": 115200,
"wait_for_upload_port": true
},
"url": "http://shop.openbci.com/",
"vendor": "OpenBCI"
}
}

197
platformio/boards/microduino.json
View File

@ -1,197 +0,0 @@
{
"1284p16m": {
"build": {
"board": "AVR_MICRODUINO_CORE_PLUS",
"core": "arduino",
"f_cpu": "16000000L",
"mcu": "atmega1284p",
"variant": "plus"
},
"frameworks": ["arduino"],
"name": "Microduino Core+ (ATmega1284P@16M,5V)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 130048,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.microduino.cc/wiki/index.php?title=Microduino-Core%2B",
"vendor": "Microduino"
},
"1284p8m": {
"build": {
"board": "AVR_MICRODUINO_CORE_PLUS",
"core": "arduino",
"f_cpu": "8000000L",
"mcu": "atmega1284p",
"variant": "plus"
},
"frameworks": ["arduino"],
"name": "Microduino Core+ (ATmega1284P@8M,3.3V)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 130048,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "https://www.microduino.cc/wiki/index.php?title=Microduino-Core%2B",
"vendor": "Microduino"
},
"168pa16m": {
"build": {
"board": "AVR_MICRODUINO_CORE",
"core": "arduino",
"f_cpu": "16000000L",
"mcu": "atmega168p",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "Microduino Core (Atmega168PA@16M,5V)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 15872,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.microduino.cc/wiki/index.php?title=Microduino-Core",
"vendor": "Microduino"
},
"168pa8m": {
"build": {
"board": "AVR_MICRODUINO_CORE",
"core": "arduino",
"f_cpu": "8000000L",
"mcu": "atmega168p",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "Microduino Core (Atmega168PA@8M,3.3V)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 15872,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "https://www.microduino.cc/wiki/index.php?title=Microduino-Core",
"vendor": "Microduino"
},
"328p16m": {
"build": {
"board": "AVR_MICRODUINO_CORE",
"core": "arduino",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "Microduino Core (Atmega328P@16M,5V)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 32256,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.microduino.cc/wiki/index.php?title=Microduino-Core",
"vendor": "Microduino"
},
"328p8m": {
"build": {
"board": "AVR_MICRODUINO_CORE",
"core": "arduino",
"f_cpu": "8000000L",
"mcu": "atmega328p",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "Microduino Core (Atmega328P@8M,3.3V)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 32256,
"require_upload_port" : true,
"protocol": "arduino",
"speed": 57600
},
"url": "https://www.microduino.cc/wiki/index.php?title=Microduino-Core",
"vendor": "Microduino"
},
"32u416m": {
"build": {
"board": "AVR_MICRODUINO_CORE_USB",
"core": "arduino",
"f_cpu": "16000000L",
"mcu": "atmega32u4",
"variant": "32u4",
"hwid": [
["0x2341", "0x8036"]
]
},
"frameworks": ["arduino"],
"name": "Microduino Core USB (ATmega32U4@16M,5V)",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "https://www.microduino.cc/wiki/index.php?title=Microduino-CoreUSB",
"vendor": "Microduino"
},
"644pa16m": {
"build": {
"board": "AVR_MICRODUINO_CORE_PLUS",
"core": "arduino",
"f_cpu": "16000000L",
"mcu": "atmega644p",
"variant": "plus"
},
"frameworks": ["arduino"],
"name": "Microduino Core+ (Atmega644PA@16M,5V)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 4096,
"maximum_size": 64512,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.microduino.cc/wiki/index.php?title=Microduino-Core%2B",
"vendor": "Microduino"
},
"644pa8m": {
"build": {
"board": "AVR_MICRODUINO_CORE_PLUS",
"core": "arduino",
"f_cpu": "8000000L",
"mcu": "atmega644p",
"variant": "plus"
},
"frameworks": ["arduino"],
"name": "Microduino Core+ (Atmega644PA@8M,3.3V)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 4096,
"maximum_size": 64512,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "https://www.microduino.cc/wiki/index.php?title=Microduino-Core%2B",
"vendor": "Microduino"
}
}

155
platformio/boards/mightycore.json
View File

@ -1,155 +0,0 @@
{
"mightycore1284": {
"build": {
"core": "MightyCore",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ATmega1284",
"f_cpu": "16000000L",
"mcu": "atmega1284p",
"variant": "mightycore"
},
"frameworks": ["arduino"],
"name": "MightyCore ATmega1284",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 130048,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.tindie.com/products/MCUdude/dip-40-arduino-compatible-development-board",
"vendor": "Mcudude"
},
"mightycore644": {
"build": {
"core": "MightyCore",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ATmega644",
"f_cpu": "16000000L",
"mcu": "atmega644p",
"variant": "mightycore"
},
"frameworks": ["arduino"],
"name": "MightyCore ATmega644",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 4096,
"maximum_size": 64512,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.tindie.com/products/MCUdude/dip-40-arduino-compatible-development-board",
"vendor": "Mcudude"
},
"mightycore324": {
"build": {
"core": "MightyCore",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ATmega324",
"f_cpu": "16000000L",
"mcu": "atmega324p",
"variant": "mightycore"
},
"frameworks": ["arduino"],
"name": "MightyCore ATmega324",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 32256,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.tindie.com/products/MCUdude/dip-40-arduino-compatible-development-board",
"vendor": "Mcudude"
},
"mightycore164": {
"build": {
"core": "MightyCore",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ATmega164",
"f_cpu": "16000000L",
"mcu": "atmega164p",
"variant": "mightycore"
},
"frameworks": ["arduino"],
"name": "MightyCore ATmega164",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 15872,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.tindie.com/products/MCUdude/dip-40-arduino-compatible-development-board",
"vendor": "Mcudude"
},
"mightycore32": {
"build": {
"core": "MightyCore",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ATmega32",
"f_cpu": "16000000L",
"mcu": "atmega32",
"variant": "mightycore"
},
"frameworks": ["arduino"],
"name": "MightyCore ATmega32",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 32256,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.tindie.com/products/MCUdude/dip-40-arduino-compatible-development-board",
"vendor": "Mcudude"
},
"mightycore16": {
"build": {
"core": "MightyCore",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ATmega16",
"f_cpu": "16000000L",
"mcu": "atmega16",
"variant": "mightycore"
},
"frameworks": ["arduino"],
"name": "MightyCore ATmega16",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 15872,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.tindie.com/products/MCUdude/dip-40-arduino-compatible-development-board",
"vendor": "Mcudude"
},
"mightycore8535": {
"build": {
"core": "MightyCore",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ATmega8535",
"f_cpu": "16000000L",
"mcu": "atmega16",
"variant": "mightycore"
},
"frameworks": ["arduino"],
"name": "MightyCore ATmega8535",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 512,
"maximum_size": 7680,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.tindie.com/products/MCUdude/dip-40-arduino-compatible-development-board",
"vendor": "Mcudude"
}
}

742
platformio/boards/misc.json
View File

@ -1,742 +0,0 @@
{
"ardhat": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_ARDHAT",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "ubIQio Ardhat",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 32256,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://ardhat.com",
"vendor": "ubIQio"
},
"raspduino": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_RASPDUINO",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "BitWizard Raspduino",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 30720,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "http://www.bitwizard.nl/wiki/index.php/Raspduino",
"vendor": "BitWizard"
},
"sainSmartDue": {
"build": {
"core": "arduino",
"extra_flags": "-D__SAM3X8E__ -DARDUINO_SAM_DUE -DARDUINO_ARCH_SAM",
"f_cpu": "84000000L",
"mcu": "at91sam3x8e",
"cpu": "cortex-m3",
"usb_product": "Arduino Due",
"variant": "arduino_due_x",
"ldscript": "sam3x8e.ld",
"hwid": [
["0x2341", "0x003E"]
]
},
"frameworks": ["arduino"],
"name": "SainSmart Due (Programming Port)",
"platform": "atmelsam",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 32768,
"maximum_size": 524288,
"protocol": "sam-ba",
"require_upload_port" : true,
"use_1200bps_touch": true,
"wait_for_upload_port": false
},
"url": "http://www.sainsmart.com/arduino/control-boards/sainsmart-due-atmel-sam3x8e-arm-cortex-m3-board-black.html",
"vendor": "SainSmart"
},
"sainSmartDueUSB": {
"build": {
"core": "arduino",
"extra_flags": "-D__SAM3X8E__ -DARDUINO_SAM_DUE -DARDUINO_ARCH_SAM",
"f_cpu": "84000000L",
"mcu": "at91sam3x8e",
"cpu": "cortex-m3",
"usb_product": "Arduino Due",
"variant": "arduino_due_x",
"ldscript": "sam3x8e.ld",
"hwid": [
["0x2341", "0x003E"]
]
},
"frameworks": ["arduino"],
"name": "SainSmart Due (USB Native Port)",
"platform": "atmelsam",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 32768,
"maximum_size": 524288,
"protocol": "sam-ba",
"require_upload_port" : true,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://www.sainsmart.com/arduino/control-boards/sainsmart-due-atmel-sam3x8e-arm-cortex-m3-board-black.html",
"vendor": "SainSmart"
},
"panStampAVR": {
"build": {
"core": "panstamp",
"extra_flags": "-DPANSTAMP_AVR",
"f_cpu": "8000000L",
"mcu": "atmega328p",
"variant": "panstamp"
},
"frameworks": ["arduino"],
"name": "PanStamp AVR",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 32256,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "http://www.panstamp.com/product/panstamp-avr/",
"vendor": "PanStamp"
},
"panStampNRG": {
"build": {
"core": "panstamp",
"f_cpu": "12000000L",
"mcu": "cc430f5137",
"variant": "panstamp_nrg_1.1"
},
"frameworks": ["arduino"],
"name": "PanStamp NRG 1.1",
"platform": "timsp430",
"upload": {
"maximum_ram_size": 4096,
"maximum_size": 32640,
"protocol": "flash-bsl"
},
"url": "http://www.panstamp.com/product/197/",
"vendor": "PanStamp"
},
"reprap_rambo": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_RAMBO",
"f_cpu": "16000000L",
"mcu": "atmega2560",
"variant": "rambo"
},
"frameworks": ["arduino"],
"name": "RepRap RAMBo",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 258048,
"protocol": "wiring",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://reprap.org/wiki/Rambo",
"vendor": "RepRap"
},
"sanguino_atmega1284p": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_SANGUINO",
"f_cpu": "16000000L",
"mcu": "atmega1284p",
"variant": "sanguino"
},
"frameworks": ["arduino"],
"name": "Sanguino ATmega1284p (16MHz)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 130048,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://code.google.com/p/sanguino/",
"vendor": "Sanguino"
},
"sanguino_atmega1284_8m": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_SANGUINO",
"f_cpu": "8000000L",
"mcu": "atmega1284p",
"variant": "sanguino"
},
"frameworks": ["arduino"],
"name": "Sanguino ATmega1284p (8MHz)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 130048,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "https://code.google.com/p/sanguino/",
"vendor": "Sanguino"
},
"sanguino_atmega644": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_SANGUINO",
"f_cpu": "16000000L",
"mcu": "atmega644",
"variant": "sanguino"
},
"frameworks": ["arduino"],
"name": "Sanguino ATmega644 or ATmega644A (16 MHz)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 4096,
"maximum_size": 64512,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://code.google.com/p/sanguino/",
"vendor": "Sanguino"
},
"sanguino_atmega644_8m": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_SANGUINO",
"f_cpu": "8000000L",
"mcu": "atmega644",
"variant": "sanguino"
},
"frameworks": ["arduino"],
"name": "Sanguino ATmega644 or ATmega644A (8 MHz)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 4096,
"maximum_size": 64512,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "https://code.google.com/p/sanguino/",
"vendor": "Sanguino"
},
"sanguino_atmega644p": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_SANGUINO",
"f_cpu": "16000000L",
"mcu": "atmega644p",
"variant": "sanguino"
},
"frameworks": ["arduino"],
"name": "Sanguino ATmega644P or ATmega644PA (16 MHz)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 4096,
"maximum_size": 64512,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://code.google.com/p/sanguino/",
"vendor": "Sanguino"
},
"sanguino_atmega644p_8m": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_SANGUINO",
"f_cpu": "8000000L",
"mcu": "atmega644p",
"variant": "sanguino"
},
"frameworks": ["arduino"],
"name": "Sanguino ATmega644P or ATmega644PA (8 MHz)",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 4096,
"maximum_size": 64512,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "https://code.google.com/p/sanguino/",
"vendor": "Sanguino"
},
"tinyduino": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_LILYPAD",
"f_cpu": "8000000L",
"mcu": "atmega328p",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "TinyCircuits TinyDuino Processor Board",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 30720,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "https://tiny-circuits.com/tinyduino-processor-board.html",
"vendor": "TinyCircuits"
},
"blend": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR",
"f_cpu": "16000000L",
"mcu": "atmega32u4",
"usb_product": "RedBearLab Blend",
"variant": "leonardo",
"hwid": [
["0x2341", "0x8036"]
]
},
"frameworks": ["arduino"],
"name": "RedBearLab Blend",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://redbearlab.com/blend/",
"vendor": "RedBearLab"
},
"blendmicro8": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR",
"f_cpu": "8000000L",
"mcu": "atmega32u4",
"usb_product": "RedBearLab Blend",
"variant": "micro",
"hwid": [
["0x03EB", "0x2404"]
]
},
"frameworks": ["arduino"],
"name": "RedBearLab Blend Micro 3.3V/8MHz",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://redbearlab.com/blendmicro/",
"vendor": "RedBearLab"
},
"blendmicro16": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR",
"f_cpu": "16000000L",
"mcu": "atmega32u4",
"usb_product": "RedBearLab Blend",
"variant": "micro",
"hwid": [
["0x03EB", "0x2404"]
]
},
"frameworks": ["arduino"],
"name": "RedBearLab Blend Micro 3.3V/16MHz (overclock)",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://redbearlab.com/blendmicro/",
"vendor": "RedBearLab"
},
"tinylily": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_LILYPAD",
"f_cpu": "8000000L",
"mcu": "atmega328p",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "TinyCircuits TinyLily Mini Processor",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 30720,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 57600
},
"url": "https://tiny-circuits.com/tiny-lily-mini-processor.html",
"vendor": "TinyCircuits"
},
"lightup": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_LEONARDO",
"f_cpu": "8000000L",
"mcu": "atmega32u4",
"usb_product": "LightUp",
"variant": "leonardo",
"hwid": [
["0x1d50", "0x6096"]
]
},
"frameworks": ["arduino"],
"name": "LightUp",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "https://www.lightup.io/",
"vendor": "LightUp"
},
"moteino": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_MOTEINO",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "LowPowerLab Moteino",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 31744,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://lowpowerlab.com/shop/moteino-r4",
"vendor": "LowPowerLab"
},
"moteinomega": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_MOTEINOMEGA",
"f_cpu": "16000000L",
"mcu": "atmega1284p",
"variant": "moteinomega"
},
"frameworks": ["arduino"],
"name": "LowPowerLab MoteinoMEGA",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 130048,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://lowpowerlab.com/blog/2014/08/09/moteinomega-available-now/",
"vendor": "LowPowerLab"
},
"zumbt328": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_BT",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "eightanaloginputs"
},
"frameworks": ["arduino"],
"name": "BQ ZUM BT-328",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2048,
"maximum_size": 28672,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 19200
},
"url": "http://www.bq.com/gb/products/zum.html",
"vendor": "BQ"
},
"quirkbot": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DQUIRKBOT",
"f_cpu": "8000000L",
"mcu": "atmega32u4",
"variant" : "quirkbot",
"usb_product": "Quirkbot",
"hwid": [
["0x2886", "0xf004"],
["0x2886", "0xf005"],
["0x2886", "0xf006"],
["0x2886", "0xf007"]
]
},
"frameworks": ["arduino"],
"name": "Quirkbot",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "http://quirkbot.com",
"vendor": "Quirkbot"
},
"wildfirev2": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_MEGA",
"f_cpu": "16000000L",
"mcu": "atmega1284p",
"variant": "wildfirev2"
},
"frameworks": ["arduino"],
"name": "Wicked Device WildFire V2",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 122878,
"protocol": "wiring",
"require_upload_port" : true,
"speed": 38400
},
"url": "http://shop.wickeddevice.com/resources/wildfire/",
"vendor": "Wicked Device"
},
"wildfirev3": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_MEGA",
"f_cpu": "16000000L",
"mcu": "atmega1284p",
"variant": "wildfirev3"
},
"frameworks": ["arduino"],
"name": "Wicked Device WildFire V3",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 130048,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "http://shop.wickeddevice.com/resources/wildfire/",
"vendor": "Wicked Device"
},
"attiny13": {
"build": {
"core": "core13",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ATTINY13",
"f_cpu": "9600000L",
"mcu": "attiny13"
},
"frameworks": ["arduino"],
"name": "Generic ATTiny13",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 64,
"maximum_size": 1024,
"protocol": "arduinoisp",
"require_upload_port" : true,
"speed": 19200
},
"url": "http://www.atmel.com/devices/ATTINY13.aspx",
"vendor": "Generic ATTiny"
},
"attiny24": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ATTINY24",
"f_cpu": "8000000L",
"mcu": "attiny24",
"variant": "tiny14"
},
"frameworks": ["arduino"],
"name": "Generic ATTiny24",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 128,
"maximum_size": 2048,
"protocol": "usbtiny"
},
"url": "http://www.atmel.com/devices/ATTINY24.aspx",
"vendor": "Generic ATTiny"
},
"attiny25": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ATTINY25",
"f_cpu": "8000000L",
"mcu": "attiny25",
"variant": "tiny8"
},
"frameworks": ["arduino"],
"name": "Generic ATTiny25",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 128,
"maximum_size": 2048,
"protocol": "usbtiny"
},
"url": "http://www.atmel.com/devices/ATTINY25.aspx",
"vendor": "Generic ATTiny"
},
"attiny44": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ATTINY44",
"f_cpu": "8000000L",
"mcu": "attiny44",
"variant": "tiny14"
},
"frameworks": ["arduino"],
"name": "Generic ATTiny44",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 256,
"maximum_size": 4096,
"protocol": "usbtiny"
},
"url": "http://www.atmel.com/devices/ATTINY44.aspx",
"vendor": "Generic ATTiny"
},
"attiny45": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ATTINY45",
"f_cpu": "8000000L",
"mcu": "attiny45",
"variant": "tiny8"
},
"frameworks": ["arduino"],
"name": "Generic ATTiny45",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 256,
"maximum_size": 4096,
"protocol": "usbtiny"
},
"url": "http://www.atmel.com/devices/ATTINY45.aspx",
"vendor": "Generic ATTiny"
},
"attiny84": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ATTINY84",
"f_cpu": "8000000L",
"mcu": "attiny84",
"variant": "tiny14"
},
"frameworks": ["arduino"],
"name": "Generic ATTiny84",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 512,
"maximum_size": 8192,
"protocol": "usbtiny"
},
"url": "http://www.atmel.com/devices/ATTINY84.aspx",
"vendor": "Generic ATTiny"
},
"attiny85": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_ATTINY85",
"f_cpu": "8000000L",
"mcu": "attiny85",
"variant": "tiny8"
},
"frameworks": ["arduino"],
"name": "Generic ATTiny85",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 512,
"maximum_size": 8192,
"protocol": "usbtiny"
},
"url": "http://www.atmel.com/devices/ATTINY85.aspx",
"vendor": "Generic ATTiny"
}
}

182
platformio/boards/nordicnrf51.json
View File

@ -1,182 +0,0 @@
{
"nrf51_mkit": {
"build": {
"f_cpu": "16000000L",
"cpu": "cortex-m0",
"mcu": "nrf51822"
},
"frameworks": ["mbed"],
"name": "Nordic nRF51822-mKIT",
"platform": "nordicnrf51",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 131072
},
"url": "http://developer.mbed.org/platforms/Nordic-nRF51822/",
"vendor": "Nordic"
},
"hrm1017": {
"build": {
"f_cpu": "16000000L",
"cpu": "cortex-m0",
"mcu": "nrf51822"
},
"frameworks": ["mbed"],
"name": "Switch Science mbed HRM1017",
"platform": "nordicnrf51",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/mbed-HRM1017/",
"vendor": "Switch Science"
},
"redBearLab": {
"build": {
"f_cpu": "16000000L",
"cpu": "cortex-m0",
"mcu": "nrf51822"
},
"frameworks": ["mbed"],
"name": "RedBearLab nRF51822",
"platform": "nordicnrf51",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/RedBearLab-nRF51822/",
"vendor": "RedBearLab"
},
"nrf51_dk": {
"build": {
"f_cpu": "32000000L",
"cpu": "cortex-m0",
"mcu": "nrf51822"
},
"frameworks": ["mbed"],
"name": "Nordic nRF51-DK",
"platform": "nordicnrf51",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/Nordic-nRF51-DK/",
"vendor": "Nordic"
},
"redBearLabBLENano": {
"build": {
"f_cpu": "16000000L",
"cpu": "cortex-m0",
"mcu": "nrf51822"
},
"frameworks": ["mbed"],
"name": "RedBearLab BLE Nano",
"platform": "nordicnrf51",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/RedBearLab-BLE-Nano/",
"vendor": "RedBearLab"
},
"nrf51_dongle": {
"build": {
"f_cpu": "32000000L",
"cpu": "cortex-m0",
"mcu": "nrf51822"
},
"frameworks": ["mbed"],
"name": "Nordic nRF51-Dongle",
"platform": "nordicnrf51",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/Nordic-nRF51-Dongle/",
"vendor": "Nordic"
},
"wallBotBLE": {
"build": {
"f_cpu": "16000000L",
"cpu": "cortex-m0",
"mcu": "nrf51822"
},
"frameworks": ["mbed"],
"name": "JKSoft Wallbot BLE",
"platform": "nordicnrf51",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 131072
},
"url": "https://developer.mbed.org/platforms/JKSoft-Wallbot-BLE/",
"vendor": "JKSoft"
},
"seeedTinyBLE": {
"build": {
"f_cpu": "16000000L",
"cpu": "cortex-m0",
"mcu": "nrf51822"
},
"frameworks": ["mbed"],
"name": "SeeedStudio Seeed Tiny BLE",
"platform": "nordicnrf51",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 262144
},
"url": "http://developer.mbed.org/platforms/Seeed-Tiny-BLE/",
"vendor": "SeeedStudio"
},
"dfcm_nnn40": {
"build": {
"f_cpu": "32000000L",
"cpu": "cortex-m0",
"mcu": "nrf51822"
},
"frameworks": ["mbed"],
"name": "Delta DFCM-NNN40",
"platform": "nordicnrf51",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/Delta-DFCM-NNN40/",
"vendor": "Delta"
},
"rfduino": {
"build": {
"core": "arduino",
"extra_flags": "-D__RFduino__",
"f_cpu": "16000000L",
"ldscript": "RFduino.ld",
"cpu": "cortex-m0",
"mcu": "nrf51822",
"variant": "RFduino"
},
"frameworks": ["arduino"],
"name": "RFduino",
"platform": "nordicnrf51",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 131072
},
"url": "http://www.rfduino.com/product/rfd22102-rfduino-dip/index.html",
"vendor": "RFduino"
},
"bbcmicrobit": {
"build": {
"f_cpu": "16000000L",
"cpu": "cortex-m0",
"mcu": "nrf51822"
},
"frameworks": ["mbed"],
"name": "BBC micro:bit",
"platform": "nordicnrf51",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/Microbit/",
"vendor": "BBC"
}
}

210
platformio/boards/nxplpc.json
View File

@ -1,210 +0,0 @@
{
"lpc1768": {
"build": {
"f_cpu": "96000000L",
"cpu": "cortex-m3",
"mcu": "lpc1768"
},
"frameworks": ["mbed"],
"name": "NXP mbed LPC1768",
"platform": "nxplpc",
"upload": {
"maximum_ram_size": 65536,
"maximum_size": 524288
},
"url": "http://developer.mbed.org/platforms/mbed-LPC1768/",
"vendor": "NXP"
},
"lpc11u24": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0",
"mcu": "lpc11u24"
},
"frameworks": ["mbed"],
"name": "NXP mbed LPC11U24",
"platform": "nxplpc",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 32768
},
"url": "https://developer.mbed.org/platforms/mbed-LPC11U24/",
"vendor": "NXP"
},
"lpc4088": {
"build": {
"f_cpu": "120000000L",
"cpu": "cortex-m4",
"mcu": "lpc4088"
},
"frameworks": ["mbed"],
"name": "Embedded Artists LPC4088 QuickStart Board",
"platform": "nxplpc",
"upload": {
"maximum_ram_size": 98304,
"maximum_size": 524288
},
"url": "https://developer.mbed.org/platforms/EA-LPC4088/",
"vendor": "Embedded Artists"
},
"dipcortexm0": {
"build": {
"f_cpu": "50000000L",
"cpu": "cortex-m0",
"mcu": "lpc11u24"
},
"frameworks": ["mbed"],
"name": "Solder Splash Labs DipCortex M0",
"platform": "nxplpc",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 32768
},
"url": "https://developer.mbed.org/platforms/DipCortex-M0/",
"vendor": "Solder Splash Labs"
},
"blueboard_lpc11u24": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0",
"mcu": "lpc11u24"
},
"frameworks": ["mbed"],
"name": "NGX Technologies BlueBoard-LPC11U24",
"platform": "nxplpc",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 32768
},
"url": "https://developer.mbed.org/platforms/BlueBoard-LPC11U24/",
"vendor": "NGX Technologies"
},
"seeeduinoArchPro": {
"build": {
"f_cpu": "96000000L",
"cpu": "cortex-m3",
"mcu": "lpc1768"
},
"frameworks": ["mbed"],
"name": "SeeedStudio Seeeduino-Arch-Pro",
"platform": "nxplpc",
"upload": {
"maximum_ram_size": 65536,
"maximum_size": 524288
},
"url": "https://developer.mbed.org/platforms/Seeeduino-Arch-Pro/",
"vendor": "SeeedStudio"
},
"ubloxc027": {
"build": {
"f_cpu": "96000000L",
"cpu": "cortex-m3",
"mcu": "lpc1768"
},
"frameworks": ["mbed"],
"name": "u-blox C027",
"platform": "nxplpc",
"upload": {
"maximum_ram_size": 65536,
"maximum_size": 524288
},
"url": "https://developer.mbed.org/platforms/u-blox-C027/",
"vendor": "u-blox"
},
"lpc1114fn28": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0",
"mcu": "lpc1114fn28"
},
"frameworks": ["mbed"],
"name": "Switch Science mbed LPC1114FN28",
"platform": "nxplpc",
"upload": {
"maximum_ram_size": 4096,
"maximum_size": 32768
},
"url": "https://developer.mbed.org/platforms/LPC1114FN28/",
"vendor": "Switch Science"
},
"lpc11u35": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0",
"mcu": "lpc11u35"
},
"frameworks": ["mbed"],
"name": "Embedded Artists LPC11U35 QuickStart Board",
"platform": "nxplpc",
"upload": {
"maximum_ram_size": 10240,
"maximum_size": 65536
},
"url": "https://developer.mbed.org/platforms/EA-LPC11U35/",
"vendor": "Embedded Artists"
},
"lpc11u35_501": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0",
"mcu": "lpc11u35"
},
"frameworks": ["mbed"],
"name": "CQ Publishing TG-LPC11U35-501",
"platform": "nxplpc",
"upload": {
"maximum_ram_size": 10240,
"maximum_size": 65536
},
"url": "https://developer.mbed.org/platforms/TG-LPC11U35-501/",
"vendor": "CQ Publishing"
},
"lpc1549": {
"build": {
"f_cpu": "72000000L",
"cpu": "cortex-m3",
"mcu": "lpc1549"
},
"frameworks": ["mbed"],
"name": "NXP LPCXpresso1549",
"platform": "nxplpc",
"upload": {
"maximum_ram_size": 36864,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/LPCXpresso1549/",
"vendor": "NXP"
},
"mbuino": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0",
"mcu": "lpc11u24"
},
"frameworks": ["mbed"],
"name": "Outrageous Circuits mBuino",
"platform": "nxplpc",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 32768
},
"url": "https://developer.mbed.org/platforms/Outrageous-Circuits-mBuino/",
"vendor": "Outrageous Circuits"
},
"lpc4088_dm": {
"build": {
"f_cpu": "120000000L",
"cpu": "cortex-m4",
"mcu": "lpc4088"
},
"frameworks": ["mbed"],
"name": "Embedded Artists LPC4088 Display Module",
"platform": "nxplpc",
"upload": {
"maximum_ram_size": 98304,
"maximum_size": 524288
},
"url": "https://developer.mbed.org/platforms/EA-LPC4088-Display-Module/",
"vendor": "Embedded Artists"
}
}

22
platformio/boards/punchthrough.json
View File

@ -1,22 +0,0 @@
{
"lightblue-bean": {
"name": "LightBlue Bean",
"vendor": "Punch Through",
"url": "https://punchthrough.com/bean",
"platform": "atmelavr",
"frameworks": ["arduino"],
"build": {
"core": "bean",
"variant": "bean",
"extra_flags": "-DARDUINO_ARCH_AVR",
"mcu": "atmega328p",
"f_cpu": "8000000L"
},
"upload": {
"maximum_size": 32256,
"maximum_ram_size": 2048
}
}
}

52
platformio/boards/raspberrypi.json
View File

@ -1,52 +0,0 @@
{
"raspberrypi_1b": {
"build": {
"extra_flags": "-DRASPBERRYPI -DRASPBERRYPI1",
"f_cpu": "700000000L",
"mcu": "bcm2835"
},
"frameworks": ["wiringpi"],
"name": "Raspberry Pi 1 Model B",
"platform": "linux_arm",
"upload": {
"maximum_ram_size": 536870912,
"maximum_size": 536870912
},
"url": "https://www.raspberrypi.org",
"vendor": "Raspberry Pi"
},
"raspberrypi_2b": {
"build": {
"extra_flags": "-DRASPBERRYPI -DRASPBERRYPI2",
"f_cpu": "900000000L",
"mcu": "bcm2836"
},
"frameworks": ["wiringpi"],
"name": "Raspberry Pi 2 Model B",
"platform": "linux_arm",
"upload": {
"maximum_ram_size": 1073741824,
"maximum_size": 1073741824
},
"url": "https://www.raspberrypi.org",
"vendor": "Raspberry Pi"
},
"raspberrypi_zero": {
"build": {
"extra_flags": "-DRASPBERRYPI -DRASPBERRYPIZERO",
"f_cpu": "1000000000L",
"mcu": "bcm2835"
},
"frameworks": ["wiringpi"],
"name": "Raspberry Pi Zero",
"platform": "linux_arm",
"upload": {
"maximum_ram_size": 536870912,
"maximum_size": 536870912
},
"url": "https://www.raspberrypi.org",
"vendor": "Raspberry Pi"
}
}

103
platformio/boards/siliconlabsefm32.json
View File

@ -1,103 +0,0 @@
{
"efm32wg_stk3800": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m4",
"mcu": "efm32wg990f256"
},
"frameworks": ["mbed"],
"name": "Silicon Labs EFM32WG-STK3800 (Wonder Gecko)",
"platform": "siliconlabsefm32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/EFM32-Wonder-Gecko/",
"vendor": "Silicon Labs"
},
"efm32gg_stk3700": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m3",
"mcu": "efm32gg990f1024"
},
"frameworks": ["mbed"],
"name": "Silicon Labs EFM32GG-STK3700 (Giant Gecko)",
"platform": "siliconlabsefm32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 1048576
},
"url": "https://developer.mbed.org/platforms/EFM32-Giant-Gecko/",
"vendor": "Silicon Labs"
},
"efm32lg_stk3600": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m3",
"mcu": "efm32lg990f256"
},
"frameworks": ["mbed"],
"name": "Silicon Labs EFM32LG-STK3600 (Leopard Gecko)",
"platform": "siliconlabsefm32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/EFM32-Leopard-Gecko/",
"vendor": "Silicon Labs"
},
"efm32zg_stk3200": {
"build": {
"f_cpu": "24000000L",
"cpu": "cortex-m0plus",
"mcu": "efm2zg222f32"
},
"frameworks": ["mbed"],
"name": "Silicon Labs EFM32ZG-STK3200 (Zero Gecko)",
"platform": "siliconlabsefm32",
"upload": {
"maximum_ram_size": 4096,
"maximum_size": 32768
},
"url": "https://developer.mbed.org/platforms/EFM32-Zero-Gecko/",
"vendor": "Silicon Labs"
},
"efm32hg_stk3400": {
"build": {
"f_cpu": "24000000L",
"cpu": "cortex-m3",
"mcu": "efm32hg322f64"
},
"frameworks": ["mbed"],
"name": "Silicon Labs SLSTK3400A USB-enabled (Happy Gecko)",
"platform": "siliconlabsefm32",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 65536
},
"url": "https://developer.mbed.org/platforms/EFM32-Happy-Gecko/",
"vendor": "Silicon Labs"
},
"efm32pg_stk3401": {
"build": {
"f_cpu": "40000000L",
"cpu": "cortex-m4",
"mcu": "efm32pg1b200f256"
},
"frameworks": ["mbed"],
"name": "Silicon Labs SLSTK3401A (Pearl Gecko)",
"platform": "siliconlabsefm32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/EFM32-Pearl-Gecko/",
"vendor": "Silicon Labs"
}
}

242
platformio/boards/sparkfun.json
View File

@ -1,242 +0,0 @@
{
"sparkfun_redboard": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_UNO",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "SparkFun RedBoard",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 32256,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.sparkfun.com/products/12757",
"vendor": "SparkFun"
},
"sparkfun_promicro16": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_PROMICRO16",
"f_cpu": "16000000L",
"mcu": "atmega32u4",
"usb_product": "SparkFun Pro Micro",
"variant": "sparkfun_promicro",
"hwid": [
["0x1B4F", "0x9205"],
["0x1B4F", "0x9206"]
]
},
"frameworks": ["arduino"],
"name": "SparkFun Pro Micro 5V/16MHz",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "https://www.sparkfun.com/products/12640",
"vendor": "SparkFun"
},
"sparkfun_promicro8": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_PROMICRO8",
"f_cpu": "8000000L",
"mcu": "atmega32u4",
"usb_product": "SparkFun Pro Micro",
"variant": "sparkfun_promicro",
"hwid": [
["0x1B4F", "0x9203"],
["0x1B4F", "0x9204"]
]
},
"frameworks": ["arduino"],
"name": "SparkFun Pro Micro 3.3V/8MHz",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "https://www.sparkfun.com/products/12587",
"vendor": "SparkFun"
},
"sparkfun_fiov3": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_FIOV3",
"f_cpu": "8000000L",
"mcu": "atmega32u4",
"usb_product": "SparkFun Fio v3",
"variant": "sparkfun_promicro",
"hwid": [
["0x1B4F", "0xF100"],
["0x1B4F", "0xF101"]
]
},
"frameworks": ["arduino"],
"name": "SparkFun Fio V3 3.3V/8MHz",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "https://www.sparkfun.com/products/11520",
"vendor": "SparkFun"
},
"sparkfun_makeymakey": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DAVR_MAKEYMAKEY",
"f_cpu": "16000000L",
"mcu": "atmega32u4",
"usb_product": "SparkFun MaKey",
"variant": "sparkfun_promicro",
"hwid": [
["0x1B4F", "0x2B74"],
["0x1B4F", "0x2B75"]
]
},
"frameworks": ["arduino"],
"name": "SparkFun Makey Makey",
"platform": "atmelavr",
"upload": {
"disable_flushing": true,
"maximum_ram_size": 2560,
"maximum_size": 28672,
"protocol": "avr109",
"require_upload_port" : true,
"speed": 57600,
"use_1200bps_touch": true,
"wait_for_upload_port": true
},
"url": "https://www.sparkfun.com/products/11511",
"vendor": "SparkFun"
},
"sparkfun_megapro16MHz": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_MEGA2560",
"f_cpu": "16000000L",
"mcu": "atmega2560",
"variant": "mega"
},
"frameworks": ["arduino"],
"name": "SparkFun Mega Pro 5V/16MHz",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 258048,
"protocol": "stk500v2",
"speed": 57600
},
"url": "https://www.sparkfun.com/products/11007",
"vendor": "SparkFun"
},
"sparkfun_megapro8MHz": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_MEGA2560",
"f_cpu": "8000000L",
"mcu": "atmega2560",
"variant": "mega"
},
"frameworks": ["arduino"],
"name": "SparkFun Mega Pro 3.3V/8MHz",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 258048,
"protocol": "stk500v2",
"speed": 57600
},
"url": "https://www.sparkfun.com/products/10744",
"vendor": "SparkFun"
},
"sparkfun_megamini": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_MEGA2560",
"f_cpu": "8000000L",
"mcu": "atmega2560",
"variant": "mega"
},
"frameworks": ["arduino"],
"name": "SparkFun Mega Pro Mini 3.3V",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 258048,
"protocol": "stk500v2",
"speed": 57600
},
"url": "https://www.sparkfun.com/products/10743",
"vendor": "SparkFun"
},
"sparkfun_digitalsandbox": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_UNO",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "SparkFun Digital Sandbox",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 32256,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.sparkfun.com/products/12651",
"vendor": "SparkFun"
},
"uview": {
"build": {
"core": "arduino",
"extra_flags": "-DARDUINO_ARCH_AVR -DARDUINO_AVR_UNO",
"f_cpu": "16000000L",
"mcu": "atmega328p",
"variant": "standard"
},
"frameworks": ["arduino"],
"name": "SparkFun MicroView",
"platform": "atmelavr",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 32256,
"protocol": "arduino",
"require_upload_port" : true,
"speed": 115200
},
"url": "https://www.sparkfun.com/products/12923",
"vendor": "SparkFun"
}
}

625
platformio/boards/ststm32.json
View File

@ -1,625 +0,0 @@
{
"disco_f407vg": {
"build": {
"core": "stm32",
"extra_flags": "-DSTM32F4 -DSTM32F407xx -DSTM32F40_41xxx",
"f_cpu": "168000000L",
"ldscript": "stm32f405x6.ld",
"cpu": "cortex-m4",
"mcu": "stm32f407vgt6",
"variant": "stm32f407xx"
},
"frameworks": ["mbed", "cmsis", "spl", "libopencm3"],
"name": "ST STM32F4DISCOVERY",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 1048576
},
"url": "http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/LN1848/PF252419",
"vendor": "ST"
},
"disco_l152rb": {
"build": {
"core": "stm32",
"extra_flags": "-DSTM32L1 -DSTM32L152xB -DSTM32L1XX_MD",
"f_cpu": "32000000L",
"ldscript": "stm32l15xx6.ld",
"cpu": "cortex-m3",
"mcu": "stm32l152rbt6",
"variant": "stm32l152xb"
},
"frameworks": ["cmsis", "spl", "libopencm3"],
"name": "ST STM32LDISCOVERY",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 131072
},
"url": "http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/LN1848/PF258515",
"vendor": "ST"
},
"disco_f303vc": {
"build": {
"core": "stm32",
"extra_flags": "-DSTM32F3 -DSTM32F303xC",
"f_cpu": "72000000L",
"ldscript": "stm32f30xx.ld",
"cpu": "cortex-m4",
"mcu": "stm32f303vct6",
"variant": "stm32f303xc"
},
"frameworks": ["mbed", "cmsis", "spl", "libopencm3"],
"name": "ST STM32F3DISCOVERY",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 49152,
"maximum_size": 262144
},
"url": "http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/LN1848/PF254044",
"vendor": "ST"
},
"disco_f100rb": {
"build": {
"f_cpu": "24000000L",
"cpu": "cortex-m3",
"mcu": "stm32f100rbt6"
},
"frameworks": ["mbed"],
"name": "ST STM32VLDISCOVERY",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 131072
},
"url": "http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/LN1848/PF250863",
"vendor": "ST"
},
"disco_f051r8": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0",
"mcu": "stm32f051r8t6"
},
"frameworks": ["mbed"],
"name": "ST STM32F0DISCOVERY",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 65536
},
"url": "http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/LN1848/PF253215",
"vendor": "ST"
},
"disco_f334c8": {
"build": {
"f_cpu": "72000000L",
"cpu": "cortex-m4",
"mcu": "stm32f334c8t6"
},
"frameworks": ["mbed"],
"name": "ST 32F3348DISCOVERY",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 65536
},
"url": "http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/LN1848/PF260318",
"vendor": "ST"
},
"disco_f401vc": {
"build": {
"f_cpu": "84000000L",
"cpu": "cortex-m4",
"mcu": "stm32f401vct6"
},
"frameworks": ["mbed"],
"name": "ST 32F401CDISCOVERY",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 65536,
"maximum_size": 262144
},
"url": "http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/LN1848/PF259098",
"vendor": "ST"
},
"disco_f429zi": {
"build": {
"f_cpu": "180000000L",
"cpu": "cortex-m4",
"mcu": "stm32f429zit6"
},
"frameworks": ["mbed"],
"name": "ST 32F429IDISCOVERY",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 262144,
"maximum_size": 2097152
},
"url": "http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/LN1848/PF259090",
"vendor": "ST"
},
"nucleo_f030r8": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0",
"mcu": "stm32f030r8t6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo F030R8",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 65536
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-F030R8/",
"vendor": "ST"
},
"nucleo_f070rb": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0",
"mcu": "stm32f070rbt6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo F070RB",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 131072
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-F070RB/",
"vendor": "ST"
},
"nucleo_f072rb": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0",
"mcu": "stm32f072rbt6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo F072RB",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 131072
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-F072RB/",
"vendor": "ST"
},
"nucleo_f091rc": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0",
"mcu": "stm32f091rct6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo F091RC",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 262144
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-F091RC/",
"vendor": "ST"
},
"nucleo_f103rb": {
"build": {
"core": "stm32",
"f_cpu": "72000000L",
"ldscript": "stm32f103xb.ld",
"cpu": "cortex-m3",
"mcu": "stm32f103rbt6",
"variant": "stm32f1"
},
"frameworks": ["mbed","libopencm3"],
"name": "ST Nucleo F103RB",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 20480,
"maximum_size": 131072
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-F103RB/",
"vendor": "ST"
},
"nucleo_f302r8": {
"build": {
"f_cpu": "72000000L",
"cpu": "cortex-m4",
"mcu": "stm32f302r8t6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo F302R8",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 65536
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-F302R8/",
"vendor": "ST"
},
"nucleo_f303re": {
"build": {
"f_cpu": "72000000L",
"cpu": "cortex-m4",
"mcu": "stm32f303ret6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo F303RE",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 65536,
"maximum_size": 524288
},
"url": "http://developer.mbed.org/platforms/ST-Nucleo-F303RE/",
"vendor": "ST"
},
"nucleo_f334r8": {
"build": {
"f_cpu": "72000000L",
"cpu": "cortex-m4",
"mcu": "stm32f334r8t6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo F334R8",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 65536
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-F334R8/",
"vendor": "ST"
},
"nucleo_f401re": {
"build": {
"core": "stm32",
"extra_flags": "-DSTM32F4 -DSTM32F401xE -DSTM32F40_41xxx",
"f_cpu": "84000000L",
"ldscript": "stm32f401xe.ld",
"cpu": "cortex-m4",
"mcu": "stm32f401ret6",
"variant": "stm32f401xe"
},
"frameworks": ["mbed", "cmsis", "spl"],
"name": "ST Nucleo F401RE",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 98304,
"maximum_size": 524288
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-F401RE/",
"vendor": "ST"
},
"nucleo_f411re": {
"build": {
"f_cpu": "100000000L",
"cpu": "cortex-m4",
"mcu": "stm32f411ret6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo F411RE",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 524288
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-F411RE/",
"vendor": "ST"
},
"nucleo_f446re": {
"build": {
"f_cpu": "180000000L",
"cpu": "cortex-m4",
"mcu": "stm32f446ret6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo F446RE",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 524288
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-F446RE/",
"vendor": "ST"
},
"nucleo_l053r8": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0",
"mcu": "stm32l053r8t6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo L053R8",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 65536
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-L053R8/",
"vendor": "ST"
},
"nucleo_l152re": {
"build": {
"f_cpu": "32000000L",
"cpu": "cortex-m3",
"mcu": "stm32l152ret6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo L152RE",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 81920,
"maximum_size": 524288
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-L152RE/",
"vendor": "ST"
},
"armstrap_eagle512": {
"build": {
"core": "stm32",
"extra_flags": "-DSTM32F40_41xxx",
"f_cpu": "168000000L",
"ldscript": "armstrap_eagle_512.ld",
"cpu": "cortex-m4",
"mcu": "stm32f407vet6",
"variant": "stm32f4"
},
"frameworks": ["cmsis", "spl"],
"name": "Armstrap Eagle 512",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 196608,
"maximum_size": 524288
},
"url": "http://docs.armstrap.org/en/latest/hardware-overview.html",
"vendor": "Armstrap"
},
"armstrap_eagle1024": {
"build": {
"core": "stm32",
"extra_flags": "-DSTM32F40_41xxx",
"f_cpu": "168000000L",
"ldscript": "armstrap_eagle_1024.ld",
"cpu": "cortex-m4",
"mcu": "stm32f417vgt6",
"variant": "stm32f4"
},
"frameworks": ["cmsis", "spl"],
"name": "Armstrap Eagle 1024",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 196608,
"maximum_size": 1048576
},
"url": "http://docs.armstrap.org/en/latest/hardware-overview.html",
"vendor": "Armstrap"
},
"armstrap_eagle2048": {
"build": {
"core": "stm32",
"extra_flags": "-DSTM32F427_437xx",
"f_cpu": "168000000L",
"ldscript": "armstrap_eagle_2048.ld",
"cpu": "cortex-m4",
"mcu": "stm32f427vit6",
"variant": "stm32f4"
},
"frameworks": ["cmsis", "spl"],
"name": "Armstrap Eagle 2048",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 262144,
"maximum_size": 2091752
},
"url": "http://docs.armstrap.org/en/latest/hardware-overview.html",
"vendor": "Armstrap"
},
"disco_l053c8": {
"build": {
"f_cpu": "32000000L",
"cpu": "cortex-m0plus",
"mcu": "stm32l053c8t6"
},
"frameworks": ["mbed"],
"name": "ST 32L0538DISCOVERY",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 65536
},
"url": "http://www.st.com/web/en/catalog/tools/PF260319",
"vendor": "ST"
},
"disco_f334c8": {
"build": {
"f_cpu": "72000000L",
"cpu": "cortex-m4",
"mcu": "stm32f334c8t6"
},
"frameworks": ["mbed"],
"name": "ST 32F3348DISCOVERY",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 12288,
"maximum_size": 65536
},
"url": "http://www.st.com/web/en/catalog/tools/PF260318",
"vendor": "ST"
},
"disco_f469ni": {
"build": {
"f_cpu": "180000000L",
"cpu": "cortex-m4",
"mcu": "stm32f469nih6"
},
"frameworks": ["mbed"],
"name": "ST 32F469IDISCOVERY",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 393216,
"maximum_size": 1048576
},
"url": "http://www.st.com/web/catalog/tools/FM116/CL1620/SC959/SS1532/LN1848/PF262395",
"vendor": "ST"
},
"disco_l476vg": {
"build": {
"f_cpu": "80000000L",
"cpu": "cortex-m4",
"mcu": "stm32l476vgt6"
},
"frameworks": ["mbed"],
"name": "ST 32L476GDISCOVERY",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 1048576
},
"url": "http://www.st.com/web/catalog/tools/FM116/CL1620/SC959/SS1532/LN1848/PF261635",
"vendor": "ST"
},
"nucleo_f031k6": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0",
"mcu": "stm32f031k6t6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo F031K6",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 4096,
"maximum_size": 32768
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-F031K6/",
"vendor": "ST"
},
"nucleo_f042k6": {
"build": {
"f_cpu": "48000000L",
"cpu": "cortex-m0",
"mcu": "stm32f042k6t6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo F042K6",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 6144,
"maximum_size": 32768
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-F042K6/",
"vendor": "ST"
},
"nucleo_f303k8": {
"build": {
"f_cpu": "72000000L",
"cpu": "cortex-m4",
"mcu": "stm32f303k8t6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo F303K8",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 65536
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-F303K8/",
"vendor": "ST"
},
"nucleo_l476rg": {
"build": {
"f_cpu": "80000000L",
"cpu": "cortex-m4",
"mcu": "stm32l476rgt6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo L476RG",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 1048576
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-L476RG/",
"vendor": "ST"
},
"nucleo_f410rb": {
"build": {
"f_cpu": "100000000L",
"cpu": "cortex-m4",
"mcu": "stm32f410rbt6"
},
"frameworks": ["mbed"],
"name": "ST Nucleo F410RB",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 131072
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-F410RB/",
"vendor": "ST"
},
"nucleo_l073rz": {
"build": {
"f_cpu": "32000000L",
"cpu": "cortex-m0plus",
"mcu": "stm32l073rz"
},
"frameworks": ["mbed"],
"name": "ST Nucleo L073RZ",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 20480,
"maximum_size": 196608
},
"url": "https://developer.mbed.org/platforms/ST-Nucleo-L073RZ/",
"vendor": "ST"
},
"seeedArchMax": {
"build": {
"f_cpu": "168000000L",
"cpu": "cortex-m4",
"mcu": "stm32f407vet6"
},
"frameworks": ["mbed"],
"name": "SeeedStudio Arch Max",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 196608,
"maximum_size": 524288
},
"url": "https://developer.mbed.org/platforms/Seeed-Arch-Max/",
"vendor": "SeeedStudio"
},
"b96b_f446ve": {
"build": {
"f_cpu": "168000000L",
"cpu": "cortex-m4",
"mcu": "stm32f446vet6"
},
"frameworks": ["mbed"],
"name": "96Boards B96B-F446VE",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 524288
},
"url": "https://developer.mbed.org/platforms/ST-B96B-F446VE/",
"vendor": "96Boards"
},
"mts_mdot_f411re": {
"build": {
"f_cpu": "100000000L",
"cpu": "cortex-m4",
"mcu": "stm32f411ret6"
},
"frameworks": ["mbed"],
"name": "MultiTech mDot F411",
"platform": "ststm32",
"upload": {
"maximum_ram_size": 131072,
"maximum_size": 524288
},
"url": "https://developer.mbed.org/platforms/MTS-mDot-F411/",
"vendor": "MultiTech"
}
}

95
platformio/boards/teensy.json
View File

@ -1,95 +0,0 @@
{
"teensy20": {
"build": {
"core": "teensy",
"f_cpu": "16000000L",
"mcu": "atmega32u4"
},
"frameworks": ["arduino"],
"name": "Teensy 2.0",
"platform": "teensy",
"upload": {
"maximum_ram_size": 2560,
"maximum_size": 32256
},
"url": "https://www.pjrc.com/store/teensy.html",
"vendor": "Teensy"
},
"teensy20pp": {
"build": {
"core": "teensy",
"f_cpu": "16000000L",
"mcu": "at90usb1286"
},
"frameworks": ["arduino"],
"name": "Teensy++ 2.0",
"platform": "teensy",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 130048
},
"url": "https://www.pjrc.com/store/teensypp.html",
"vendor": "Teensy"
},
"teensy30": {
"build": {
"core": "teensy3",
"extra_flags": "-D__MK20DX128__",
"f_cpu": "48000000L",
"ldscript": "mk20dx128.ld",
"mcu": "mk20dx128",
"cpu": "cortex-m4"
},
"frameworks": ["arduino"],
"name": "Teensy 3.0",
"platform": "teensy",
"upload": {
"maximum_ram_size": 16384,
"maximum_size": 131072
},
"url": "https://www.pjrc.com/store/teensy3.html",
"vendor": "Teensy"
},
"teensy31": {
"build": {
"core": "teensy3",
"extra_flags": "-D__MK20DX256__",
"f_cpu": "72000000L",
"ldscript": "mk20dx256.ld",
"mcu": "mk20dx256",
"cpu": "cortex-m4"
},
"frameworks": ["arduino", "mbed"],
"name": "Teensy 3.1 / 3.2",
"platform": "teensy",
"upload": {
"maximum_ram_size": 65536,
"maximum_size": 262144
},
"url": "https://www.pjrc.com/store/teensy31.html",
"vendor": "Teensy"
},
"teensylc": {
"build": {
"core": "teensy3",
"extra_flags": "-D__MKL26Z64__",
"f_cpu": "48000000L",
"ldscript": "mkl26z64.ld",
"mcu": "mkl26z64",
"cpu": "cortex-m0plus"
},
"frameworks": ["arduino"],
"name": "Teensy LC",
"platform": "teensy",
"upload": {
"maximum_ram_size": 8192,
"maximum_size": 63488
},
"url": "http://www.pjrc.com/teensy/teensyLC.html",
"vendor": "Teensy"
}
}

164
platformio/boards/timsp430.json
View File

@ -1,164 +0,0 @@
{
"lpmsp430f5529": {
"build": {
"core": "msp430",
"f_cpu": "16000000L",
"mcu": "msp430f5529",
"variant": "launchpad_f5529"
},
"frameworks": ["energia"],
"name": "TI LaunchPad w/ msp430f5529 (16MHz)",
"platform": "timsp430",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 131072,
"protocol": "tilib"
},
"url": "http://www.ti.com/ww/en/launchpad/launchpads-msp430-msp-exp430f5529lp.html",
"vendor": "TI"
},
"lpmsp430f5529_25": {
"build": {
"core": "msp430",
"f_cpu": "25000000L",
"mcu": "msp430f5529",
"variant": "launchpad_f5529"
},
"frameworks": ["energia"],
"name": "TI LaunchPad w/ msp430f5529 (25MHz)",
"platform": "timsp430",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 131072,
"protocol": "tilib"
},
"url": "http://www.ti.com/ww/en/launchpad/launchpads-msp430-msp-exp430f5529lp.html",
"vendor": "TI"
},
"lpmsp430fr5739": {
"build": {
"core": "msp430",
"f_cpu": "16000000L",
"mcu": "msp430fr5739",
"variant": "fraunchpad"
},
"frameworks": ["energia"],
"name": "TI FraunchPad w/ msp430fr5739",
"platform": "timsp430",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 15872,
"protocol": "rf2500"
},
"url": "http://www.ti.com/tool/msp-exp430fr5739",
"vendor": "TI"
},
"lpmsp430fr5969": {
"build": {
"core": "msp430",
"f_cpu": "8000000L",
"mcu": "msp430fr5969",
"variant": "launchpad_fr5969"
},
"frameworks": ["energia"],
"name": "TI LaunchPad w/ msp430fr5969",
"platform": "timsp430",
"upload": {
"maximum_ram_size": 1024,
"maximum_size": 65536,
"protocol": "tilib"
},
"url": "http://www.ti.com/ww/en/launchpad/launchpads-msp430-msp-exp430fr5969.html",
"vendor": "TI"
},
"lpmsp430g2231": {
"build": {
"core": "msp430",
"f_cpu": "1000000L",
"mcu": "msp430g2231",
"variant": "launchpad"
},
"frameworks": ["energia"],
"name": "TI LaunchPad w/ msp430g2231 (1 MHz)",
"platform": "timsp430",
"upload": {
"maximum_ram_size": 128,
"maximum_size": 2048,
"protocol": "rf2500"
},
"url": "http://www.ti.com/ww/en/launchpad/launchpads-msp430-msp-exp430g2.html",
"vendor": "TI"
},
"lpmsp430g2452": {
"build": {
"core": "msp430",
"f_cpu": "16000000L",
"mcu": "msp430g2452",
"variant": "launchpad"
},
"frameworks": ["energia"],
"name": "TI LaunchPad w/ msp430g2452 (16MHz)",
"platform": "timsp430",
"upload": {
"maximum_ram_size": 256,
"maximum_size": 8192,
"protocol": "rf2500"
},
"url": "http://www.ti.com/ww/en/launchpad/launchpads-msp430-msp-exp430g2.html",
"vendor": "TI"
},
"lpmsp430g2553": {
"build": {
"core": "msp430",
"f_cpu": "16000000L",
"mcu": "msp430g2553",
"variant": "launchpad"
},
"frameworks": ["energia"],
"name": "TI LaunchPad w/ msp430g2553 (16MHz)",
"platform": "timsp430",
"upload": {
"maximum_ram_size": 512,
"maximum_size": 16384,
"protocol": "rf2500"
},
"url": "http://www.ti.com/ww/en/launchpad/launchpads-msp430-msp-exp430g2.html",
"vendor": "TI"
},
"lpmsp430fr4133": {
"build": {
"core": "msp430",
"f_cpu": "16000000L",
"mcu": "msp430g2553",
"variant": "launchpad_fr4133"
},
"frameworks": ["energia"],
"name": "TI LaunchPad w/ msp430fr4133",
"platform": "timsp430",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 15360,
"protocol": "tilib"
},
"url": "http://www.ti.com/tool/msp-exp430fr4133",
"vendor": "TI"
},
"lpmsp430fr6989": {
"build": {
"core": "msp430",
"f_cpu": "16000000L",
"mcu": "msp430g2553",
"variant": "launchpad_fr6989"
},
"frameworks": ["energia"],
"name": "TI LaunchPad w/ msp430fr6989",
"platform": "timsp430",
"upload": {
"maximum_ram_size": 2048,
"maximum_size": 130048,
"protocol": "tilib"
},
"url": "http://www.ti.com/tool/msp-exp430fr6989",
"vendor": "TI"
}
}

59
platformio/boards/titiva.json
View File

@ -1,59 +0,0 @@
{
"lplm4f120h5qr": {
"build": {
"core": "lm4f",
"f_cpu": "80000000L",
"ldscript": "lm4fcpp_blizzard.ld",
"cpu": "cortex-m4",
"mcu": "lplm4f120h5qr",
"variant": "stellarpad"
},
"frameworks": ["energia", "libopencm3"],
"name": "TI LaunchPad (Stellaris) w/ lm4f120 (80MHz)",
"platform": "titiva",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 262144
},
"url": "http://www.ti.com/tool/ek-lm4f120xl",
"vendor": "TI"
},
"lptm4c1230c3pm": {
"build": {
"core": "lm4f",
"f_cpu": "80000000L",
"ldscript": "lm4fcpp_blizzard.ld",
"cpu": "cortex-m4",
"mcu": "lptm4c1230c3pm",
"variant": "stellarpad"
},
"frameworks": ["energia", "libopencm3"],
"name": "TI LaunchPad (Tiva C) w/ tm4c123 (80MHz)",
"platform": "titiva",
"upload": {
"maximum_ram_size": 32768,
"maximum_size": 262144
},
"url": "http://www.ti.com/ww/en/launchpad/launchpads-connected-ek-tm4c123gxl.html",
"vendor": "TI"
},
"lptm4c1294ncpdt": {
"build": {
"core": "lm4f",
"f_cpu": "120000000L",
"ldscript": "lm4fcpp_snowflake.ld",
"cpu": "cortex-m4",
"mcu": "lptm4c1294ncpdt",
"variant": "launchpad_129"
},
"frameworks": ["energia", "libopencm3"],
"name": "TI LaunchPad (Tiva C) w/ tm4c129 (120MHz)",
"platform": "titiva",
"upload": {
"maximum_ram_size": 262144,
"maximum_size": 1048576
},
"url": "http://www.ti.com/ww/en/launchpad/launchpads-connected-ek-tm4c1294xl.html",
"vendor": "TI"
}
}

13
platformio/builder/scripts/__init__.py
View File

@ -1,13 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

168
platformio/builder/scripts/atmelavr.py
View File

@ -1,168 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for Atmel AVR series of microcontrollers
"""
from os.path import join
from time import sleep
from SCons.Script import (COMMAND_LINE_TARGETS, AlwaysBuild, Default,
DefaultEnvironment, SConscript)
from platformio.util import get_serialports
def BeforeUpload(target, source, env): # pylint: disable=W0613,W0621
if "program" in COMMAND_LINE_TARGETS:
return
if "micronucleus" in env['UPLOADER']:
print "Please unplug/plug device ..."
upload_options = env.get("BOARD_OPTIONS", {}).get("upload", {})
# Deprecated: compatibility with old projects. Use `program` instead
if "usb" in env.subst("$UPLOAD_PROTOCOL"):
upload_options['require_upload_port'] = False
env.Replace(UPLOAD_SPEED=None)
if env.subst("$UPLOAD_SPEED"):
env.Append(UPLOADERFLAGS=["-b", "$UPLOAD_SPEED"])
if upload_options and not upload_options.get("require_upload_port", False):
return
env.AutodetectUploadPort()
env.Append(UPLOADERFLAGS=["-P", '"$UPLOAD_PORT"'])
if env.subst("$BOARD") == "raspduino":
def _rpi_sysgpio(path, value):
with open(path, "w") as f:
f.write(str(value))
_rpi_sysgpio("/sys/class/gpio/export", 18)
_rpi_sysgpio("/sys/class/gpio/gpio18/direction", "out")
_rpi_sysgpio("/sys/class/gpio/gpio18/value", 1)
sleep(0.1)
_rpi_sysgpio("/sys/class/gpio/gpio18/value", 0)
_rpi_sysgpio("/sys/class/gpio/unexport", 18)
else:
if not upload_options.get("disable_flushing", False):
env.FlushSerialBuffer("$UPLOAD_PORT")
before_ports = [i['port'] for i in get_serialports()]
if upload_options.get("use_1200bps_touch", False):
env.TouchSerialPort("$UPLOAD_PORT", 1200)
if upload_options.get("wait_for_upload_port", False):
env.Replace(UPLOAD_PORT=env.WaitForNewSerialPort(before_ports))
env = DefaultEnvironment()
SConscript(env.subst(join("$PIOBUILDER_DIR", "scripts", "baseavr.py")))
env.Append(
CFLAGS=[
"-std=gnu11"
],
CXXFLAGS=[
"-std=gnu++11"
]
)
if "digispark" in env.get(
"BOARD_OPTIONS", {}).get("build", {}).get("core", ""):
env.Replace(
UPLOADER=join("$PIOPACKAGES_DIR", "tool-micronucleus", "micronucleus"),
UPLOADERFLAGS=[
"-c", "$UPLOAD_PROTOCOL",
"--timeout", "60"
],
UPLOADHEXCMD='"$UPLOADER" $UPLOADERFLAGS $SOURCES'
)
else:
env.Replace(
UPLOADER=join("$PIOPACKAGES_DIR", "tool-avrdude", "avrdude"),
UPLOADERFLAGS=[
"-v",
"-p", "$BOARD_MCU",
"-C",
'"%s"' % join("$PIOPACKAGES_DIR", "tool-avrdude", "avrdude.conf"),
"-c", "$UPLOAD_PROTOCOL"
],
UPLOADHEXCMD='"$UPLOADER" $UPLOADERFLAGS -D -U flash:w:$SOURCES:i',
UPLOADEEPCMD='"$UPLOADER" $UPLOADERFLAGS -U eeprom:w:$SOURCES:i',
PROGRAMHEXCMD='"$UPLOADER" $UPLOADERFLAGS -U flash:w:$SOURCES:i'
)
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Target: Build the .hex file
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.hex")
else:
target_firm = env.ElfToHex(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload by default .hex file
#
upload = env.Alias(["upload", "uploadlazy"], target_firm,
[BeforeUpload, "$UPLOADHEXCMD"])
AlwaysBuild(upload)
#
# Target: Upload EEPROM data (from EEMEM directive)
#
uploadeep = env.Alias(
"uploadeep",
env.ElfToEep(join("$BUILD_DIR", "firmware"), target_elf),
[BeforeUpload, "$UPLOADEEPCMD"])
AlwaysBuild(uploadeep)
#
# Target: Upload firmware using external programmer
#
program = env.Alias("program", target_firm, [BeforeUpload, "$PROGRAMHEXCMD"])
AlwaysBuild(program)
#
# Setup default targets
#
Default([target_firm, target_size])

189
platformio/builder/scripts/atmelsam.py
View File

@ -1,189 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for Atmel SAM series of microcontrollers
"""
from os.path import basename, join
from SCons.Script import (COMMAND_LINE_TARGETS, AlwaysBuild, Default,
DefaultEnvironment, SConscript)
from platformio.util import get_serialports
def BeforeUpload(target, source, env): # pylint: disable=W0613,W0621
env.AutodetectUploadPort()
board_type = env.subst("$BOARD")
if "zero" not in board_type:
env.Append(
UPLOADERFLAGS=[
"-U",
"true" if ("usb" in board_type.lower(
) or board_type == "digix") else "false"
])
upload_options = env.get("BOARD_OPTIONS", {}).get("upload", {})
if not upload_options.get("disable_flushing", False):
env.FlushSerialBuffer("$UPLOAD_PORT")
before_ports = [i['port'] for i in get_serialports()]
if upload_options.get("use_1200bps_touch", False):
env.TouchSerialPort("$UPLOAD_PORT", 1200)
if upload_options.get("wait_for_upload_port", False):
env.Replace(UPLOAD_PORT=env.WaitForNewSerialPort(before_ports))
# use only port name for BOSSA
if "/" in env.subst("$UPLOAD_PORT"):
env.Replace(UPLOAD_PORT=basename(env.subst("$UPLOAD_PORT")))
env = DefaultEnvironment()
SConscript(env.subst(join("$PIOBUILDER_DIR", "scripts", "basearm.py")))
if env.subst("$BOARD") == "zero":
env.Replace(
UPLOADER=join("$PIOPACKAGES_DIR", "tool-openocd", "bin", "openocd"),
UPLOADERFLAGS=[
"-d2",
"-s",
join(
"$PIOPACKAGES_DIR",
"tool-openocd", "share", "openocd", "scripts"),
"-f",
join(
"$PLATFORMFW_DIR", "variants",
"${BOARD_OPTIONS['build']['variant']}", "openocd_scripts",
"${BOARD_OPTIONS['build']['variant']}.cfg"
),
"-c", "\"telnet_port", "disabled;",
"program", "{{$SOURCES}}",
"verify", "reset", "0x00002000;", "shutdown\""
],
UPLOADCMD='"$UPLOADER" $UPLOADERFLAGS'
)
else:
env.Replace(
UPLOADER=join("$PIOPACKAGES_DIR", "$PIOPACKAGE_UPLOADER", "bossac"),
UPLOADERFLAGS=[
"--info",
"--port", '"$UPLOAD_PORT"',
"--erase",
"--write",
"--verify",
"--reset",
"--debug"
],
UPLOADCMD='"$UPLOADER" $UPLOADERFLAGS $SOURCES'
)
env.Append(
CCFLAGS=[
"--param", "max-inline-insns-single=500",
"-MMD"
],
CFLAGS=[
"-std=gnu11"
],
CXXFLAGS=[
"-std=gnu++11",
"-fno-threadsafe-statics"
],
CPPDEFINES=[
"USBCON",
'USB_MANUFACTURER="PlatformIO"'
],
LINKFLAGS=[
"-Wl,--check-sections",
"-Wl,--unresolved-symbols=report-all",
"-Wl,--warn-common",
"-Wl,--warn-section-align"
]
)
if "sam3x8e" in env.get("BOARD_OPTIONS", {}).get("build", {}).get("mcu", None):
env.Append(
CPPDEFINES=[
"printf=iprintf"
],
LINKFLAGS=[
"-Wl,--entry=Reset_Handler",
"-Wl,--start-group"
],
UPLOADERFLAGS=[
"--boot",
]
)
elif "zero" in env.subst("$BOARD"):
env.Append(
LINKFLAGS=[
"--specs=nosys.specs",
"--specs=nano.specs"
]
)
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Target: Build the .bin file
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.bin")
else:
target_firm = env.ElfToBin(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload by default .bin file
#
if env.subst("$BOARD") == "zero":
upload = env.Alias(["upload", "uploadlazy"], target_firm, "$UPLOADCMD")
else:
upload = env.Alias(["upload", "uploadlazy"], target_firm,
[BeforeUpload, "$UPLOADCMD"])
AlwaysBuild(upload)
#
# Setup default targets
#
Default([target_firm, target_size])

97
platformio/builder/scripts/basearm.py
View File

@ -1,97 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Base for ARM microcontrollers.
"""
from SCons.Script import Builder, DefaultEnvironment
env = DefaultEnvironment()
env.Replace(
AR="arm-none-eabi-ar",
AS="arm-none-eabi-as",
CC="arm-none-eabi-gcc",
CXX="arm-none-eabi-g++",
OBJCOPY="arm-none-eabi-objcopy",
RANLIB="arm-none-eabi-ranlib",
SIZETOOL="arm-none-eabi-size",
ARFLAGS=["rcs"],
ASFLAGS=["-x", "assembler-with-cpp"],
CCFLAGS=[
"-g", # include debugging info (so errors include line numbers)
"-Os", # optimize for size
"-ffunction-sections", # place each function in its own section
"-fdata-sections",
"-Wall",
"-mthumb",
"-mcpu=${BOARD_OPTIONS['build']['cpu']}",
"-nostdlib"
],
CXXFLAGS=[
"-fno-rtti",
"-fno-exceptions"
],
CPPDEFINES=[
"F_CPU=$BOARD_F_CPU"
],
LINKFLAGS=[
"-Os",
"-Wl,--gc-sections,--relax",
"-mthumb",
"-mcpu=${BOARD_OPTIONS['build']['cpu']}"
],
LIBS=["c", "gcc", "m"],
SIZEPRINTCMD='"$SIZETOOL" -B -d $SOURCES',
PROGNAME="firmware",
PROGSUFFIX=".elf"
)
env.Append(
ASFLAGS=env.get("CCFLAGS", [])[:],
BUILDERS=dict(
ElfToBin=Builder(
action=" ".join([
"$OBJCOPY",
"-O",
"binary",
"$SOURCES",
"$TARGET"]),
suffix=".bin"
),
ElfToHex=Builder(
action=" ".join([
"$OBJCOPY",
"-O",
"ihex",
"-R",
".eeprom",
"$SOURCES",
"$TARGET"]),
suffix=".hex"
)
)
)

98
platformio/builder/scripts/baseavr.py
View File

@ -1,98 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Base for Atmel AVR series of microcontrollers
"""
from SCons.Script import Builder, DefaultEnvironment
env = DefaultEnvironment()
env.Replace(
AR="avr-ar",
AS="avr-as",
CC="avr-gcc",
CXX="avr-g++",
OBJCOPY="avr-objcopy",
RANLIB="avr-ranlib",
SIZETOOL="avr-size",
ARFLAGS=["rcs"],
ASFLAGS=["-x", "assembler-with-cpp"],
CCFLAGS=[
"-g", # include debugging info (so errors include line numbers)
"-Os", # optimize for size
"-Wall", # show warnings
"-ffunction-sections", # place each function in its own section
"-fdata-sections",
"-mmcu=$BOARD_MCU"
],
CXXFLAGS=[
"-fno-exceptions",
"-fno-threadsafe-statics"
],
CPPDEFINES=["F_CPU=$BOARD_F_CPU"],
LINKFLAGS=[
"-Os",
"-mmcu=$BOARD_MCU",
"-Wl,--gc-sections,--relax"
],
LIBS=["m"],
SIZEPRINTCMD='"$SIZETOOL" --mcu=$BOARD_MCU -C -d $SOURCES',
PROGNAME="firmware",
PROGSUFFIX=".elf"
)
env.Append(
ASFLAGS=env.get("CCFLAGS", [])[:],
BUILDERS=dict(
ElfToEep=Builder(
action=" ".join([
"$OBJCOPY",
"-O",
"ihex",
"-j",
".eeprom",
'--set-section-flags=.eeprom="alloc,load"',
"--no-change-warnings",
"--change-section-lma",
".eeprom=0",
"$SOURCES",
"$TARGET"]),
suffix=".eep"
),
ElfToHex=Builder(
action=" ".join([
"$OBJCOPY",
"-O",
"ihex",
"-R",
".eeprom",
"$SOURCES",
"$TARGET"]),
suffix=".hex"
)
)
)

357
platformio/builder/scripts/espressif.py
View File

@ -1,357 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=redefined-outer-name
"""
Builder for Espressif MCUs
"""
import re
from os.path import join
from SCons.Script import (COMMAND_LINE_TARGETS, AlwaysBuild, Builder, Default,
DefaultEnvironment)
def _get_flash_size(env):
# use board's flash size by default
board_max_size = int(
env.get("BOARD_OPTIONS", {}).get("upload", {}).get("maximum_size", 0))
# check if user overrides LD Script
match = re.search(r"\.flash\.(\d+)(m|k).*\.ld", env.GetActualLDScript())
if match:
if match.group(2) == "k":
board_max_size = int(match.group(1)) * 1024
elif match.group(2) == "m":
board_max_size = int(match.group(1)) * 1024 * 1024
return ("%dK" % (board_max_size / 1024) if board_max_size < 1048576
else "%dM" % (board_max_size / 1048576))
def _get_board_f_flash(env):
frequency = env.subst("$BOARD_F_FLASH")
frequency = str(frequency).replace("L", "")
return int(int(frequency) / 1000000)
env = DefaultEnvironment()
env.Replace(
__get_flash_size=_get_flash_size,
__get_board_f_flash=_get_board_f_flash,
AR="xtensa-lx106-elf-ar",
AS="xtensa-lx106-elf-as",
CC="xtensa-lx106-elf-gcc",
CXX="xtensa-lx106-elf-g++",
OBJCOPY=join("$PIOPACKAGES_DIR", "tool-esptool", "esptool"),
RANLIB="xtensa-lx106-elf-ranlib",
SIZETOOL="xtensa-lx106-elf-size",
ARFLAGS=["rcs"],
ASFLAGS=["-x", "assembler-with-cpp"],
CFLAGS=[
"-std=gnu99",
"-Wpointer-arith",
"-Wno-implicit-function-declaration",
"-Wl,-EL",
"-fno-inline-functions",
"-nostdlib"
],
CCFLAGS=[
"-Os", # optimize for size
"-mlongcalls",
"-mtext-section-literals",
"-falign-functions=4",
"-U__STRICT_ANSI__",
"-ffunction-sections",
"-fdata-sections",
"-MMD" # output dependancy info
],
CXXFLAGS=[
"-fno-rtti",
"-fno-exceptions",
"-std=c++11"
],
CPPDEFINES=[
"F_CPU=$BOARD_F_CPU",
"__ets__",
"ICACHE_FLASH"
],
LINKFLAGS=[
"-Os",
"-nostdlib",
"-Wl,--no-check-sections",
"-u", "call_user_start",
"-Wl,-static",
"-Wl,--gc-sections"
],
#
# Upload
#
UPLOADER=join("$PIOPACKAGES_DIR", "tool-esptool", "esptool"),
UPLOADEROTA=join("$PLATFORMFW_DIR", "tools", "espota.py"),
UPLOADERFLAGS=[
"-vv",
"-cd", "$UPLOAD_RESETMETHOD",
"-cb", "$UPLOAD_SPEED",
"-cp", '"$UPLOAD_PORT"'
],
UPLOADEROTAFLAGS=[
"--debug",
"--progress",
"-i", "$UPLOAD_PORT",
"$UPLOAD_FLAGS"
],
UPLOADCMD='"$UPLOADER" $UPLOADERFLAGS -cf $SOURCE',
UPLOADOTACMD='"$PYTHONEXE" "$UPLOADEROTA" $UPLOADEROTAFLAGS -f $SOURCE',
#
# Misc
#
MKSPIFFSTOOL=join("$PIOPACKAGES_DIR", "tool-mkspiffs", "mkspiffs"),
SIZEPRINTCMD='"$SIZETOOL" -B -d $SOURCES',
PROGNAME="firmware",
PROGSUFFIX=".elf"
)
env.Append(
ASFLAGS=env.get("CCFLAGS", [])[:],
BUILDERS=dict(
ElfToBin=Builder(
action=" ".join([
'"$OBJCOPY"',
"-eo",
'"%s"' % join("$PLATFORMFW_DIR", "bootloaders",
"eboot", "eboot.elf"),
"-bo", "$TARGET",
"-bm", "$BOARD_FLASH_MODE",
"-bf", "${__get_board_f_flash(__env__)}",
"-bz", "${__get_flash_size(__env__)}",
"-bs", ".text",
"-bp", "4096",
"-ec",
"-eo", "$SOURCES",
"-bs", ".irom0.text",
"-bs", ".text",
"-bs", ".data",
"-bs", ".rodata",
"-bc", "-ec"
]),
suffix=".bin"
)
)
)
#
# SPIFFS
#
def _fetch_spiffs_size(target, source, env):
spiffs_re = re.compile(
r"PROVIDE\s*\(\s*_SPIFFS_(\w+)\s*=\s*(0x[\dA-F]+)\s*\)")
with open(env.GetActualLDScript()) as f:
for line in f.readlines():
match = spiffs_re.search(line)
if not match:
continue
env["SPIFFS_%s" % match.group(1).upper()] = match.group(2)
assert all([k in env for k in ["SPIFFS_START", "SPIFFS_END", "SPIFFS_PAGE",
"SPIFFS_BLOCK"]])
# esptool flash starts from 0
for k in ("SPIFFS_START", "SPIFFS_END"):
_value = 0
if int(env[k], 16) < 0x40300000:
_value = int(env[k], 16) & 0xFFFFF
else:
_value = int(env[k], 16) & 0xFFFFFF
_value -= 0x200000 # esptool offset
env[k] = hex(_value)
return (target, source)
env.Append(
BUILDERS=dict(
DataToBin=Builder(
action=" ".join([
'"$MKSPIFFSTOOL"',
"-c", "$SOURCES",
"-p", "${int(SPIFFS_PAGE, 16)}",
"-b", "${int(SPIFFS_BLOCK, 16)}",
"-s", "${int(SPIFFS_END, 16) - int(SPIFFS_START, 16)}",
"$TARGET"
]),
emitter=_fetch_spiffs_size,
source_factory=env.Dir,
suffix=".bin"
)
)
)
if "uploadfs" in COMMAND_LINE_TARGETS:
env.Append(
UPLOADERFLAGS=["-ca", "$SPIFFS_START"],
UPLOADEROTAFLAGS=["-s"]
)
#
# Framework and SDK specific configuration
#
if "FRAMEWORK" in env:
env.Append(
LINKFLAGS=[
"-Wl,-wrap,system_restart_local",
"-Wl,-wrap,register_chipv6_phy"
]
)
# Handle uploading via OTA
ota_port = None
if env.get("UPLOAD_PORT"):
ota_port = re.match(
r"\"?((([0-9]{1,3}\.){3}[0-9]{1,3})|.+\.local)\"?$",
env.get("UPLOAD_PORT"))
if ota_port:
env.Replace(UPLOADCMD="$UPLOADOTACMD")
# Configure native SDK
else:
env.Append(
CPPPATH=[
join("$PIOPACKAGES_DIR", "sdk-esp8266", "include"),
"$PROJECTSRC_DIR"
],
LIBPATH=[
join("$PIOPACKAGES_DIR", "sdk-esp8266", "lib"),
join("$PIOPACKAGES_DIR", "sdk-esp8266", "ld")
],
BUILDERS=dict(
ElfToBin=Builder(
action=" ".join([
'"$OBJCOPY"',
"-eo", "$SOURCES",
"-bo", "${TARGETS[0]}",
"-bm", "$BOARD_FLASH_MODE",
"-bf", "${__get_board_f_flash(__env__)}",
"-bz", "${__get_flash_size(__env__)}",
"-bs", ".text",
"-bs", ".data",
"-bs", ".rodata",
"-bc", "-ec",
"-eo", "$SOURCES",
"-es", ".irom0.text", "${TARGETS[1]}",
"-ec", "-v"
]),
suffix=".bin"
)
)
)
env.Replace(
LIBS=[
"c", "gcc", "phy", "pp", "net80211", "lwip", "wpa", "wpa2",
"main", "wps", "crypto", "json", "ssl", "pwm", "upgrade",
"smartconfig", "airkiss", "at"
],
UPLOADERFLAGS=[
"-vv",
"-cd", "$UPLOAD_RESETMETHOD",
"-cb", "$UPLOAD_SPEED",
"-cp", '"$UPLOAD_PORT"',
"-ca", "0x00000",
"-cf", "${SOURCES[0]}",
"-ca", "0x40000",
"-cf", "${SOURCES[1]}"
],
UPLOADCMD='"$UPLOADER" $UPLOADERFLAGS',
)
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Target: Build the .hex or SPIFFS image
#
if set(["uploadfs", "uploadfsota"]) & set(COMMAND_LINE_TARGETS):
target_firm = env.DataToBin(
join("$BUILD_DIR", "spiffs"), "$PROJECTDATA_DIR")
AlwaysBuild(target_firm)
elif "uploadlazy" in COMMAND_LINE_TARGETS:
if "FRAMEWORK" not in env:
target_firm = [
join("$BUILD_DIR", "firmware_00000.bin"),
join("$BUILD_DIR", "firmware_40000.bin")
]
else:
target_firm = join("$BUILD_DIR", "firmware.bin")
else:
if "FRAMEWORK" not in env:
target_firm = env.ElfToBin(
[join("$BUILD_DIR", "firmware_00000"),
join("$BUILD_DIR", "firmware_40000")], target_elf)
else:
target_firm = env.ElfToBin(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload firmware or SPIFFS image
#
target_upload = env.Alias(
["upload", "uploadlazy", "uploadfs"], target_firm,
[lambda target, source, env: env.AutodetectUploadPort(), "$UPLOADCMD"])
env.AlwaysBuild(target_upload)
#
# Target: Define targets
#
Default([target_firm, target_size])

13
platformio/builder/scripts/frameworks/__init__.py
View File

@ -1,13 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

339
platformio/builder/scripts/frameworks/arduino.py
View File

@ -1,339 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Arduino
Arduino Wiring-based Framework allows writing cross-platform software to
control devices attached to a wide range of Arduino boards to create all
kinds of creative coding, interactive objects, spaces or physical experiences.
http://arduino.cc/en/Reference/HomePage
"""
from os import listdir, walk
from os.path import isdir, isfile, join
from SCons.Script import DefaultEnvironment
env = DefaultEnvironment()
BOARD_OPTS = env.get("BOARD_OPTIONS", {})
BOARD_BUILDOPTS = BOARD_OPTS.get("build", {})
BOARD_CORELIBDIRNAME = BOARD_BUILDOPTS.get("core")
#
# Determine framework directory
# based on development platform
#
PLATFORMFW_DIR = join("$PIOPACKAGES_DIR",
"framework-arduino${PLATFORM.replace('atmel', '')}")
if "digispark" in BOARD_BUILDOPTS.get("core"):
BOARD_CORELIBDIRNAME = "digispark"
PLATFORMFW_DIR = join(
"$PIOPACKAGES_DIR",
"framework-arduino%s" % (
"sam" if BOARD_BUILDOPTS.get("cpu") == "cortex-m3" else "avr")
)
elif env.get("PLATFORM") == "timsp430":
PLATFORMFW_DIR = join(
"$PIOPACKAGES_DIR",
"framework-arduinomsp430"
)
elif env.get("PLATFORM") == "espressif":
env.Prepend(
CPPPATH=[
join("$PLATFORMFW_DIR", "tools", "sdk", "include"),
join("$PLATFORMFW_DIR", "tools", "sdk", "lwip", "include")
],
LIBPATH=[join("$PLATFORMFW_DIR", "tools", "sdk", "lib")],
LIBS=["mesh", "wpa2", "smartconfig", "pp", "main", "wpa", "lwip",
"net80211", "wps", "crypto", "phy", "hal", "axtls", "gcc", "m"]
)
env.VariantDirWrap(
join("$BUILD_DIR", "generic"),
join("$PIOPACKAGES_DIR", "framework-arduinoespressif",
"variants", "generic")
)
elif env.get("PLATFORM") == "nordicnrf51":
PLATFORMFW_DIR = join(
"$PIOPACKAGES_DIR",
"framework-arduinonordicnrf51"
)
env.Prepend(
CPPPATH=[
join("$PLATFORMFW_DIR", "system", "CMSIS", "CMSIS", "Include"),
join("$PLATFORMFW_DIR", "system", "RFduino"),
join("$PLATFORMFW_DIR", "system", "RFduino", "include")
],
LIBPATH=[
join(
"$PLATFORMFW_DIR",
"variants",
"${BOARD_OPTIONS['build']['variant']}"
),
join(
"$PLATFORMFW_DIR",
"variants",
"${BOARD_OPTIONS['build']['variant']}",
"linker_scripts",
"gcc"
),
],
LIBS=["RFduino", "RFduinoBLE", "RFduinoGZLL", "RFduinoSystem"]
)
elif env.get("PLATFORM") == "microchippic32":
PLATFORMFW_DIR = join(
"$PIOPACKAGES_DIR",
"framework-arduinomicrochippic32"
)
env.Prepend(
LIBPATH=[
join(
"$PLATFORMFW_DIR", "cores",
"${BOARD_OPTIONS['build']['core']}"
),
join(
"$PLATFORMFW_DIR", "variants",
"${BOARD_OPTIONS['build']['variant']}"
)
]
)
elif "intel" in env.get("PLATFORM"):
PLATFORMFW_DIR = join(
"$PIOPACKAGES_DIR",
"framework-arduinointel"
)
if BOARD_CORELIBDIRNAME == "arc32":
env.Prepend(
CPPPATH=[
join("$PLATFORMFW_DIR", "system",
"libarc32_arduino101", "drivers"),
join("$PLATFORMFW_DIR", "system",
"libarc32_arduino101", "common"),
join("$PLATFORMFW_DIR", "system",
"libarc32_arduino101", "framework", "include"),
join("$PLATFORMFW_DIR", "system",
"libarc32_arduino101", "bootcode"),
join("$BUILD_DIR", "IntelDrivers")
]
)
env.Prepend(
LIBPATH=[
join(
"$PLATFORMFW_DIR", "variants",
"${BOARD_OPTIONS['build']['variant']}"
),
join(
"$PLATFORMFW_DIR", "variants",
"${BOARD_OPTIONS['build']['variant']}",
"linker_scripts"
)
]
)
env.Replace(PLATFORMFW_DIR=PLATFORMFW_DIR)
#
# Lookup for specific core's libraries
#
if isdir(join(env.subst("$PLATFORMFW_DIR"), "libraries", "__cores__",
BOARD_CORELIBDIRNAME)):
lib_dirs = env.get("LIBSOURCE_DIRS")
lib_dirs.insert(
lib_dirs.index(join("$PLATFORMFW_DIR", "libraries")),
join(PLATFORMFW_DIR, "libraries", "__cores__", BOARD_CORELIBDIRNAME)
)
env.Replace(
LIBSOURCE_DIRS=lib_dirs
)
#
# Base
#
ARDUINO_VERSION = int(
open(join(env.subst("$PLATFORMFW_DIR"),
"version.txt")).read().replace(".", "").strip())
# usb flags
ARDUINO_USBDEFINES = []
if "usb_product" in BOARD_BUILDOPTS:
ARDUINO_USBDEFINES = [
"USB_VID=${BOARD_OPTIONS['build']['hwid'][0][0]}",
"USB_PID=${BOARD_OPTIONS['build']['hwid'][0][1]}",
'USB_PRODUCT=\\"%s\\"' % (env.subst(
"${BOARD_OPTIONS['build']['usb_product']}").replace('"', "")),
'USB_MANUFACTURER=\\"%s\\"' % (env.subst(
"${BOARD_OPTIONS['vendor']}").replace('"', ""))
]
if env.get("PLATFORM") == "teensy":
ARDUINO_USBDEFINES += [
"ARDUINO=10600",
"TEENSYDUINO=%d" % ARDUINO_VERSION
]
else:
ARDUINO_USBDEFINES += ["ARDUINO=%d" % ARDUINO_VERSION]
env.Append(
CPPDEFINES=ARDUINO_USBDEFINES,
CPPPATH=[
join("$BUILD_DIR", "FrameworkArduino")
]
)
#
# Atmel SAM platform
#
if env.subst("${PLATFORMFW_DIR}")[-3:] == "sam":
env.VariantDirWrap(
join("$BUILD_DIR", "FrameworkCMSISInc"),
join("$PLATFORMFW_DIR", "system", "CMSIS", "CMSIS", "Include")
)
env.VariantDirWrap(
join("$BUILD_DIR", "FrameworkDeviceInc"),
join("$PLATFORMFW_DIR", "system", "CMSIS", "Device", "ATMEL")
)
env.VariantDirWrap(
join("$BUILD_DIR", "FrameworkLibSam"),
join("$PLATFORMFW_DIR", "system", "libsam")
)
env.VariantDirWrap(
join("$BUILD_DIR", "FrameworkArduinoInc"),
join("$PLATFORMFW_DIR", "cores", "${BOARD_OPTIONS['build']['core']}")
)
env.Append(
CPPPATH=[
join("$BUILD_DIR", "FrameworkCMSISInc"),
join("$BUILD_DIR", "FrameworkLibSam"),
join("$BUILD_DIR", "FrameworkLibSam", "include"),
join("$BUILD_DIR", "FrameworkDeviceInc"),
join(
"$BUILD_DIR",
"FrameworkDeviceInc",
"${BOARD_OPTIONS['build']['mcu'][3:]}",
"include"
)
],
LIBPATH=[
join(
"$PLATFORMFW_DIR",
"variants",
"${BOARD_OPTIONS['build']['variant']}",
"linker_scripts",
"gcc"
)
]
)
# search relative includes in lib SAM directories
core_dir = join(env.subst("$PLATFORMFW_DIR"), "system", "libsam")
for root, _, files in walk(core_dir):
for lib_file in files:
file_path = join(root, lib_file)
if not isfile(file_path):
continue
content = None
content_changed = False
with open(file_path) as fp:
content = fp.read()
if '#include "../' in content:
content_changed = True
content = content.replace('#include "../', '#include "')
if not content_changed:
continue
with open(file_path, "w") as fp:
fp.write(content)
#
# Teensy platform
#
# Teensy 2.x Core
if BOARD_BUILDOPTS.get("core", None) == "teensy":
# search relative includes in teensy directories
core_dir = join(env.get("PIOHOME_DIR"), "packages",
"framework-arduinoteensy", "cores", "teensy")
for item in sorted(listdir(core_dir)):
file_path = join(core_dir, item)
if not isfile(file_path):
continue
content = None
content_changed = False
with open(file_path) as fp:
content = fp.read()
if '#include "../' in content:
content_changed = True
content = content.replace('#include "../', '#include "')
if not content_changed:
continue
with open(file_path, "w") as fp:
fp.write(content)
#
# Target: Build Core Library
#
libs = []
if "variant" in BOARD_BUILDOPTS:
env.Append(
CPPPATH=[
join("$BUILD_DIR", "FrameworkArduinoVariant")
]
)
libs.append(env.BuildLibrary(
join("$BUILD_DIR", "FrameworkArduinoVariant"),
join("$PLATFORMFW_DIR", "variants",
"${BOARD_OPTIONS['build']['variant']}")
))
envsafe = env.Clone()
if BOARD_BUILDOPTS.get("core", None) == "teensy3":
libs.append("arm_cortex%sl_math" % (
"M4" if BOARD_BUILDOPTS.get("cpu") == "cortex-m4" else "M0"))
if env.subst("$BOARD") == "genuino101":
libs.append("libarc32drv_arduino101")
libs.append(envsafe.BuildLibrary(
join("$BUILD_DIR", "FrameworkArduino"),
join("$PLATFORMFW_DIR", "cores", "${BOARD_OPTIONS['build']['core']}")
))
if "sam3x8e" in BOARD_BUILDOPTS.get("mcu", ""):
env.Append(
LIBPATH=[
join("$PLATFORMFW_DIR", "variants",
"${BOARD_OPTIONS['build']['variant']}")
]
)
libs.append("sam_sam3x8e_gcc_rel")
env.Prepend(LIBS=libs)

93
platformio/builder/scripts/frameworks/cmsis.py
View File

@ -1,93 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
CMSIS
The ARM Cortex Microcontroller Software Interface Standard (CMSIS) is a
vendor-independent hardware abstraction layer for the Cortex-M processor
series and specifies debugger interfaces. The CMSIS enables consistent and
simple software interfaces to the processor for interface peripherals,
real-time operating systems, and middleware. It simplifies software
re-use, reducing the learning curve for new microcontroller developers
and cutting the time-to-market for devices.
http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php
"""
from os.path import isfile, join
from SCons.Script import DefaultEnvironment
env = DefaultEnvironment()
env.Replace(
PLATFORMFW_DIR=join("$PIOPACKAGES_DIR", "framework-cmsis")
)
env.VariantDirWrap(
join("$BUILD_DIR", "FrameworkCMSIS"),
join("$PLATFORMFW_DIR", "cores", "${BOARD_OPTIONS['build']['core']}")
)
env.Append(
CPPPATH=[
join("$BUILD_DIR", "FrameworkCMSIS"),
join("$BUILD_DIR", "FrameworkCMSISCommon"),
join("$BUILD_DIR", "FrameworkCMSISVariant")
]
)
envsafe = env.Clone()
#
# Target: Build Core Library
#
# use mbed ldscript with bootloader section
ldscript = env.get("BOARD_OPTIONS", {}).get("build", {}).get("ldscript")
if not isfile(join(env.subst("$PIOPACKAGES_DIR"), "ldscripts", ldscript)):
if "mbed" in env.get("BOARD_OPTIONS", {}).get("frameworks", {}):
env.Append(
LINKFLAGS=[
'-Wl,-T"%s"' %
join(
"$PIOPACKAGES_DIR", "framework-mbed", "variant",
env.subst("$BOARD").upper(), "mbed",
"TARGET_%s" % env.subst(
"$BOARD").upper(), "TOOLCHAIN_GCC_ARM",
"%s.ld" % ldscript.upper()[:-3]
)
]
)
libs = []
libs.append(envsafe.BuildLibrary(
join("$BUILD_DIR", "FrameworkCMSISVariant"),
join(
"$PLATFORMFW_DIR", "variants",
env.subst("${BOARD_OPTIONS['build']['variant']}")[0:7],
"${BOARD_OPTIONS['build']['variant']}"
)
))
libs.append(envsafe.BuildLibrary(
join("$BUILD_DIR", "FrameworkCMSISCommon"),
join(
"$PLATFORMFW_DIR", "variants",
env.subst("${BOARD_OPTIONS['build']['variant']}")[0:7], "common"
)
))
env.Append(LIBS=libs)

74
platformio/builder/scripts/frameworks/energia.py
View File

@ -1,74 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Energia
Energia Wiring-based framework enables pretty much anyone to start easily
creating microcontroller-based projects and applications. Its easy-to-use
libraries and functions provide developers of all experience levels to start
blinking LEDs, buzzing buzzers and sensing sensors more quickly than ever
before.
http://energia.nu/reference/
"""
from os.path import join
from SCons.Script import DefaultEnvironment
env = DefaultEnvironment()
env.Replace(
PLATFORMFW_DIR=join("$PIOPACKAGES_DIR", "framework-energia${PLATFORM[2:]}")
)
ENERGIA_VERSION = int(
open(join(env.subst("$PLATFORMFW_DIR"),
"version.txt")).read().replace(".", "").strip())
# include board variant
env.VariantDirWrap(
join("$BUILD_DIR", "FrameworkEnergiaVariant"),
join("$PLATFORMFW_DIR", "variants", "${BOARD_OPTIONS['build']['variant']}")
)
env.Append(
CPPDEFINES=[
"ARDUINO=101",
"ENERGIA=%d" % ENERGIA_VERSION
],
CPPPATH=[
join("$BUILD_DIR", "FrameworkEnergia"),
join("$BUILD_DIR", "FrameworkEnergiaVariant")
]
)
if env.get("BOARD_OPTIONS", {}).get("build", {}).get("core") == "lm4f":
env.Append(
LINKFLAGS=["-Wl,--entry=ResetISR"]
)
#
# Target: Build Core Library
#
libs = []
libs.append(env.BuildLibrary(
join("$BUILD_DIR", "FrameworkEnergia"),
join("$PLATFORMFW_DIR", "cores", "${BOARD_OPTIONS['build']['core']}")
))
env.Append(LIBS=libs)

191
platformio/builder/scripts/frameworks/libopencm3.py
View File

@ -1,191 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
libOpenCM3
The libOpenCM3 framework aims to create a free/libre/open-source
firmware library for various ARM Cortex-M0(+)/M3/M4 microcontrollers,
including ST STM32, Ti Tiva and Stellaris, NXP LPC 11xx, 13xx, 15xx,
17xx parts, Atmel SAM3, Energy Micro EFM32 and others.
http://www.libopencm3.org/wiki/Main_Page
"""
from __future__ import absolute_import
import re
from os import listdir, sep, walk
from os.path import isfile, join, normpath
from SCons.Script import DefaultEnvironment
from platformio.util import exec_command
env = DefaultEnvironment()
env.Replace(
PLATFORMFW_DIR=join("$PIOPACKAGES_DIR", "framework-libopencm3")
)
BOARD_BUILDOPTS = env.get("BOARD_OPTIONS", {}).get("build", {})
def find_ldscript(src_dir):
ldscript = None
matches = []
for item in sorted(listdir(src_dir)):
_path = join(src_dir, item)
if not isfile(_path) or not item.endswith(".ld"):
continue
matches.append(_path)
if len(matches) == 1:
ldscript = matches[0]
elif isfile(join(src_dir, BOARD_BUILDOPTS['ldscript'])):
ldscript = join(src_dir, BOARD_BUILDOPTS['ldscript'])
return ldscript
def generate_nvic_files():
fw_dir = env.subst("$PLATFORMFW_DIR")
for root, _, files in walk(join(fw_dir, "include", "libopencm3")):
if "irq.json" not in files or isfile(join(root, "nvic.h")):
continue
exec_command(
["python", join("scripts", "irq2nvic_h"),
join("." + root.replace(fw_dir, ""),
"irq.json").replace("\\", "/")],
cwd=fw_dir
)
def parse_makefile_data(makefile):
data = {"includes": [], "objs": [], "vpath": ["./"]}
with open(makefile) as f:
content = f.read()
# fetch "includes"
re_include = re.compile(r"^include\s+([^\r\n]+)", re.M)
for match in re_include.finditer(content):
data['includes'].append(match.group(1))
# fetch "vpath"s
re_vpath = re.compile(r"^VPATH\s+\+?=\s+([^\r\n]+)", re.M)
for match in re_vpath.finditer(content):
data['vpath'] += match.group(1).split(":")
# fetch obj files
objs_match = re.search(
r"^OBJS\s+\+?=\s+([^\.]+\.o\s*(?:\s+\\s+)?)+", content, re.M)
assert objs_match
data['objs'] = re.sub(
r"(OBJS|[\+=\\\s]+)", "\n", objs_match.group(0)).split()
return data
def get_source_files(src_dir):
mkdata = parse_makefile_data(join(src_dir, "Makefile"))
for include in mkdata['includes']:
_mkdata = parse_makefile_data(normpath(join(src_dir, include)))
for key, value in _mkdata.iteritems():
for v in value:
if v not in mkdata[key]:
mkdata[key].append(v)
sources = []
lib_root = env.subst("$PLATFORMFW_DIR")
for obj_file in mkdata['objs']:
src_file = obj_file[:-1] + "c"
for search_path in mkdata['vpath']:
src_path = normpath(join(src_dir, search_path, src_file))
if isfile(src_path):
sources.append(join("$BUILD_DIR", "FrameworkLibOpenCM3",
src_path.replace(lib_root + sep, "")))
break
return sources
def merge_ld_scripts(main_ld_file):
def _include_callback(match):
included_ld_file = match.group(1)
# search included ld file in lib directories
for root, _, files in walk(env.subst(join("$PLATFORMFW_DIR", "lib"))):
if included_ld_file not in files:
continue
with open(join(root, included_ld_file)) as fp:
return fp.read()
return match.group(0)
content = ""
with open(main_ld_file) as f:
content = f.read()
incre = re.compile(r"^INCLUDE\s+\"?([^\.]+\.ld)\"?", re.M)
with open(main_ld_file, "w") as f:
f.write(incre.sub(_include_callback, content))
#
# Processing ...
#
if BOARD_BUILDOPTS.get("core") == "lm4f":
env.Append(
CPPDEFINES=["LM4F"]
)
env.VariantDirWrap(
join("$BUILD_DIR", "FrameworkLibOpenCM3Variant"),
join("$PLATFORMFW_DIR", "include")
)
env.Append(
CPPPATH=[
join("$BUILD_DIR", "FrameworkLibOpenCM3"),
join("$BUILD_DIR", "FrameworkLibOpenCM3Variant")
]
)
root_dir = env.subst(
join("$PLATFORMFW_DIR", "lib", BOARD_BUILDOPTS.get("core")))
if BOARD_BUILDOPTS.get("core") == "stm32":
root_dir = join(root_dir, BOARD_BUILDOPTS.get("variant")[5:7])
ldscript_path = find_ldscript(root_dir)
if ldscript_path:
merge_ld_scripts(ldscript_path)
generate_nvic_files()
# override ldscript by libopencm3
assert "LDSCRIPT_PATH" in env
env.Replace(
LDSCRIPT_PATH=ldscript_path
)
libs = []
env.VariantDirWrap(
join("$BUILD_DIR", "FrameworkLibOpenCM3"),
"$PLATFORMFW_DIR"
)
libs.append(env.Library(
join("$BUILD_DIR", "FrameworkLibOpenCM3"),
get_source_files(root_dir)
))
env.Append(LIBS=libs)

289
platformio/builder/scripts/frameworks/mbed.py
View File

@ -1,289 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
mbed
The mbed framework The mbed SDK has been designed to provide enough
hardware abstraction to be intuitive and concise, yet powerful enough to
build complex projects. It is built on the low-level ARM CMSIS APIs,
allowing you to code down to the metal if needed. In addition to RTOS,
USB and Networking libraries, a cookbook of hundreds of reusable
peripheral and module libraries have been built on top of the SDK by
the mbed Developer Community.
http://mbed.org/
"""
from __future__ import print_function
import re
import sys
import xml.etree.ElementTree as ElementTree
from binascii import crc32
from os import walk
from os.path import basename, isfile, join, normpath
from SCons.Script import DefaultEnvironment
env = DefaultEnvironment()
BOARD_OPTS = env.get("BOARD_OPTIONS", {}).get("build", {})
env.Replace(
PLATFORMFW_DIR=join("$PIOPACKAGES_DIR", "framework-mbed")
)
MBED_VARIANTS = {
"blueboard_lpc11u24": "LPC11U24",
"dipcortexm0": "LPC11U24",
"seeeduinoArchPro": "ARCH_PRO",
"seeedArchMax": "ARCH_MAX",
"ubloxc027": "UBLOX_C027",
"lpc1114fn28": "LPC1114",
"lpc11u35": "LPC11U35_401",
"mbuino": "LPC11U24",
"nrf51_mkit": "NRF51822",
"seeedTinyBLE": "SEEED_TINY_BLE",
"redBearLab": "RBLAB_NRF51822",
"nrf51-dt": "NRF51_DK",
"redBearLabBLENano": "RBLAB_BLENANO",
"wallBotBLE": "NRF51822",
"frdm_kl25z": "KL25Z",
"frdm_kl46z": "KL46Z",
"frdm_k64f": "K64F",
"frdm_kl05z": "KL05Z",
"frdm_k20d50m": "K20D50M",
"frdm_k22f": "K22F",
"teensy31": "TEENSY3_1",
"dfcm_nnn40": "DELTA_DFCM_NNN40",
"samr21_xpro": "SAMR21G18A",
"saml21_xpro_b": "SAML21J18A",
"samd21_xpro": "SAMD21J18A",
"bbcmicrobit": "NRF51822"
}
MBED_LIBS_MAP = {
"dsp": {"ar": ["dsp", "cmsis_dsp"]},
"eth": {"ar": ["eth"], "deps": ["rtos"]},
"fat": {"ar": ["fat"]},
"rtos": {"ar": ["rtos", "rtx"]},
"usb": {"ar": ["USBDevice"]},
"usb_host": {"ar": ["USBHost"]}
}
def get_mbedlib_includes():
result = []
for lib in MBED_LIBS_MAP.keys():
includes = []
lib_dir = join(env.subst("$PLATFORMFW_DIR"), "libs", lib)
for _, _, files in walk(lib_dir):
for libfile in files:
if libfile.endswith(".h"):
includes.append(libfile)
result.append((lib, set(includes)))
return result
def get_used_mbedlibs():
re_includes = re.compile(r"^(#include\s+(?:\<|\")([^\r\n\"]+))",
re.M | re.I)
srcincs = []
for root, _, files in walk(env.get("PROJECTSRC_DIR")):
for pfile in files:
if not any([pfile.endswith(ext) for ext in (".h", ".c", ".cpp")]):
continue
with open(join(root, pfile)) as fp:
srcincs.extend([i[1] for i in re_includes.findall(fp.read())])
srcincs = set(srcincs)
result = {}
for libname, libincs in get_mbedlib_includes():
if libincs & srcincs and libname not in result:
result[libname] = MBED_LIBS_MAP[libname]
return result
def add_mbedlib(libname, libar):
if libar in env.get("LIBS"):
return
lib_dir = join(env.subst("$PLATFORMFW_DIR"), "libs", libname)
if not isfile(join(lib_dir, "TARGET_%s" % variant,
"TOOLCHAIN_GCC_ARM", "lib%s.a" % libar)):
print(
"Warning: %s board doesn't have native support for '%s' library!" %
(env.get("BOARD"), libname), file=sys.stderr)
return
env.Append(
LIBPATH=[
join(env.subst("$PLATFORMFW_DIR"), "libs", libname,
"TARGET_%s" % variant, "TOOLCHAIN_GCC_ARM")
],
LIBS=[libar]
)
sysincdirs = (
"eth",
"include",
"ipv4",
"lwip-eth",
"lwip-sys"
)
for root, _, files in walk(lib_dir):
if (not any(f.endswith(".h") for f in files) and
basename(root) not in sysincdirs):
continue
var_dir = join("$BUILD_DIR", "FrameworkMbed%sInc%d" %
(libname.upper(), crc32(root)))
if var_dir in env.get("CPPPATH"):
continue
env.VariantDirWrap(var_dir, root)
env.Append(CPPPATH=[var_dir])
def parse_eix_file(filename):
result = {}
paths = (
("CFLAGS", "./Target/Source/CC/Switch"),
("CXXFLAGS", "./Target/Source/CPPC/Switch"),
("CPPDEFINES", "./Target/Source/Symbols/Symbol"),
("FILES", "./Target/Files/File"),
("LINKFLAGS", "./Target/Source/LD/Switch"),
("OBJFILES", "./Target/Source/Addobjects/Addobject"),
("LIBPATH", "./Target/Linker/Librarypaths/Librarypath"),
("STDLIBS", "./Target/Source/Syslibs/Library"),
("LDSCRIPT_PATH", "./Target/Source/Scriptfile"),
("CPPPATH", "./Target/Compiler/Includepaths/Includepath")
)
tree = ElementTree.parse(filename)
for (key, path) in paths:
if key not in result:
result[key] = []
for node in tree.findall(path):
_nkeys = node.keys()
result[key].append(
node.get(_nkeys[0]) if len(_nkeys) == 1 else node.attrib)
return result
def get_build_flags(data):
flags = {}
cflags = set(data.get("CFLAGS", []))
cxxflags = set(data.get("CXXFLAGS", []))
ccflags = set(cflags & cxxflags)
flags['CCFLAGS'] = list(ccflags)
flags['CXXFLAGS'] = list(cxxflags - ccflags)
flags['CFLAGS'] = list(cflags - ccflags)
return flags
def _mbed_whole_archive_hook(libs_):
if (not isinstance(libs_, list) or
env.get("BOARD_OPTIONS", {}).get("platform") != "ststm32"):
return libs_
_dynlibs = []
_stlibs = []
for l_ in libs_:
if isinstance(l_, basestring):
_stlibs.append(l_)
else:
_dynlibs.append(l_)
libs_ = []
if _dynlibs:
libs_.append("-Wl,-whole-archive")
libs_.extend(_dynlibs)
libs_.append("-Wl,-no-whole-archive")
libs_.extend(_stlibs)
return libs_
board_type = env.subst("$BOARD")
variant = MBED_VARIANTS[
board_type] if board_type in MBED_VARIANTS else board_type.upper()
eixdata = parse_eix_file(
join(env.subst("$PLATFORMFW_DIR"), "variant", variant, "%s.eix" % variant))
build_flags = get_build_flags(eixdata)
variant_dir = join("$PLATFORMFW_DIR", "variant", variant)
env.Replace(
_mbed_whole_archive_hook=_mbed_whole_archive_hook,
_LIBFLAGS="${_mbed_whole_archive_hook(%s)}" % env.get("_LIBFLAGS")[2:-1],
CCFLAGS=build_flags.get("CCFLAGS", []),
CFLAGS=build_flags.get("CFLAGS", []),
CXXFLAGS=build_flags.get("CXXFLAGS", []),
LINKFLAGS=eixdata.get("LINKFLAGS", []),
CPPDEFINES=[define for define in eixdata.get("CPPDEFINES", [])],
LDSCRIPT_PATH=normpath(
join(variant_dir, eixdata.get("LDSCRIPT_PATH")[0]))
)
# restore external build flags
env.ProcessFlags([
env.get("BOARD_OPTIONS", {}).get("build", {}).get("extra_flags"),
env.get("BUILD_FLAGS")
])
# Hook for K64F and K22F
if board_type in ("frdm_k22f", "frdm_k64f"):
env.Append(
LINKFLAGS=["-Wl,--start-group"]
)
for lib_path in eixdata.get("CPPPATH"):
_vdir = join("$BUILD_DIR", "FrameworkMbedInc%d" % crc32(lib_path))
env.VariantDirWrap(_vdir, join(variant_dir, lib_path))
env.Append(CPPPATH=[_vdir])
env.Append(
LIBPATH=[join(variant_dir, lib_path)
for lib_path in eixdata.get("LIBPATH", [])
if lib_path.startswith("mbed")]
)
#
# Target: Build mbed Library
#
libs = [l for l in eixdata.get("STDLIBS", []) if l not in env.get("LIBS", [])]
libs.extend(["mbed", "c", "gcc"])
libs.append(env.Library(
join("$BUILD_DIR", "FrameworkMbed"),
[join(variant_dir, f)
for f in eixdata.get("OBJFILES", [])]
))
env.Prepend(LIBS=libs)
for _libname, _libdata in get_used_mbedlibs().iteritems():
for _libar in _libdata['ar']:
add_mbedlib(_libname, _libar)
if "deps" not in _libdata:
continue
for libdep in _libdata['deps']:
for _libar in MBED_LIBS_MAP[libdep]['ar']:
add_mbedlib(libdep, _libar)

35
platformio/builder/scripts/frameworks/simba.py
View File

@ -1,35 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Simba
Simba is an RTOS and build framework. It aims to make embedded
programming easy and portable.
http://simba-os.readthedocs.org
"""
from os.path import join
from SCons.Script import DefaultEnvironment, SConscript
env = DefaultEnvironment()
env.Replace(
PLATFORMFW_DIR=join("$PIOPACKAGES_DIR", "framework-simba")
)
SConscript(
[env.subst(join("$PLATFORMFW_DIR", "make", "platformio.sconscript"))])

119
platformio/builder/scripts/frameworks/spl.py
View File

@ -1,119 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
SPL
The ST Standard Peripheral Library provides a set of functions for
handling the peripherals on the STM32 Cortex-M3 family.
The idea is to save the user (the new user, in particular) having to deal
directly with the registers.
http://www.st.com/web/en/catalog/tools/FM147/CL1794/SC961/SS1743?sc=stm32embeddedsoftware
"""
from os.path import isfile, join
from SCons.Script import DefaultEnvironment
env = DefaultEnvironment()
env.Replace(
PLATFORMFW_DIR=join("$PIOPACKAGES_DIR", "framework-spl")
)
env.VariantDirWrap(
join("$BUILD_DIR", "FrameworkCMSIS"),
join("$PLATFORMFW_DIR", "${BOARD_OPTIONS['build']['core']}",
"cmsis", "cores", "${BOARD_OPTIONS['build']['core']}")
)
env.VariantDirWrap(
join("$BUILD_DIR", "FrameworkSPLInc"),
join(
"$PLATFORMFW_DIR", "${BOARD_OPTIONS['build']['core']}", "spl",
"variants", env.subst("${BOARD_OPTIONS['build']['variant']}")[0:7],
"inc"
)
)
env.Append(
CPPPATH=[
join("$BUILD_DIR", "FrameworkCMSIS"),
join("$BUILD_DIR", "FrameworkCMSISVariant"),
join("$BUILD_DIR", "FrameworkSPLInc"),
join("$BUILD_DIR", "FrameworkSPL")
]
)
envsafe = env.Clone()
envsafe.Append(
CPPPATH=["$BUILDSRC_DIR"],
CPPDEFINES=[
"USE_STDPERIPH_DRIVER"
]
)
#
# Target: Build SPL Library
#
# use mbed ldscript with bootloader section
ldscript = env.get("BOARD_OPTIONS", {}).get("build", {}).get("ldscript")
if not isfile(join(env.subst("$PIOPACKAGES_DIR"), "ldscripts", ldscript)):
if "mbed" in env.get("BOARD_OPTIONS", {}).get("frameworks", {}):
env.Append(
LINKFLAGS=[
'-Wl,-T"%s"' %
join(
"$PIOPACKAGES_DIR", "framework-mbed", "variant",
env.subst("$BOARD").upper(), "mbed",
"TARGET_%s" % env.subst(
"$BOARD").upper(), "TOOLCHAIN_GCC_ARM",
"%s.ld" % ldscript.upper()[:-3]
)
]
)
extra_flags = env.get("BOARD_OPTIONS", {}).get("build", {}).get("extra_flags")
src_filter_patterns = ["+<*>"]
if "STM32F40_41xxx" in extra_flags:
src_filter_patterns += ["-<stm32f4xx_fmc.c>"]
if "STM32F427_437xx" in extra_flags:
src_filter_patterns += ["-<stm32f4xx_fsmc.c>"]
elif "STM32F303xC" in extra_flags:
src_filter_patterns += ["-<stm32f30x_hrtim.c>"]
elif "STM32L1XX_MD" in extra_flags:
src_filter_patterns += ["-<stm32l1xx_flash_ramfunc.c>"]
libs = []
libs.append(envsafe.BuildLibrary(
join("$BUILD_DIR", "FrameworkCMSISVariant"),
join(
"$PLATFORMFW_DIR", "${BOARD_OPTIONS['build']['core']}", "cmsis",
"variants", env.subst("${BOARD_OPTIONS['build']['variant']}")[0:7]
)
))
libs.append(envsafe.BuildLibrary(
join("$BUILD_DIR", "FrameworkSPL"),
join("$PLATFORMFW_DIR", "${BOARD_OPTIONS['build']['core']}",
"spl", "variants",
env.subst("${BOARD_OPTIONS['build']['variant']}")[0:7], "src"),
src_filter=" ".join(src_filter_patterns)
))
env.Append(LIBS=libs)

65
platformio/builder/scripts/frameworks/wiringpi.py
View File

@ -1,65 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
WiringPi
WiringPi is a GPIO access library written in C for the BCM2835 used in the
Raspberry Pi. It's designed to be familiar to people who have used the Arduino
"wiring" system.
http://wiringpi.com
"""
from os.path import join
from SCons.Script import DefaultEnvironment
env = DefaultEnvironment()
env.Replace(
CPPFLAGS=[
"-O2",
"-Wformat=2",
"-Wall",
"-Winline",
"-pipe",
"-fPIC"
],
LIBS=["pthread"]
)
env.Append(
CPPDEFINES=[
"_GNU_SOURCE"
],
CPPPATH=[
join("$BUILD_DIR", "FrameworkWiringPi")
]
)
#
# Target: Build Core Library
#
libs = []
libs.append(env.BuildLibrary(
join("$BUILD_DIR", "FrameworkWiringPi"),
join("$PIOPACKAGES_DIR", "framework-wiringpi", "wiringPi")
))
env.Append(LIBS=libs)

61
platformio/builder/scripts/freescalekinetis.py
View File

@ -1,61 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for Freescale Kinetis series ARM microcontrollers.
"""
from os.path import join
from SCons.Script import (COMMAND_LINE_TARGETS, AlwaysBuild, Default,
DefaultEnvironment, SConscript)
env = DefaultEnvironment()
SConscript(env.subst(join("$PIOBUILDER_DIR", "scripts", "basearm.py")))
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Target: Build the .bin file
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.bin")
else:
target_firm = env.ElfToBin(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload by default .bin file
#
upload = env.Alias(["upload", "uploadlazy"], target_firm, env.UploadToDisk)
AlwaysBuild(upload)
#
# Target: Define targets
#
Default([target_firm, target_size])

200
platformio/builder/scripts/intel_arc32.py
View File

@ -1,200 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for Intel ARC32 microcontrollers
"""
from os.path import join
from SCons.Script import (COMMAND_LINE_TARGETS, AlwaysBuild, Builder, Default,
DefaultEnvironment)
def BeforeUpload(target, source, env): # pylint: disable=W0613,W0621
if "program" in COMMAND_LINE_TARGETS:
return
env.AutodetectUploadPort()
env.Prepend(UPLOADERFLAGS=['"$UPLOAD_PORT"'])
if env.get("BOARD_OPTIONS", {}).get("upload", {}).get(
"use_1200bps_touch", False):
env.TouchSerialPort("$UPLOAD_PORT", 1200)
env = DefaultEnvironment()
env.Replace(
AR="arc-elf32-ar",
AS="arc-elf32-as",
CC="arc-elf32-gcc",
CXX="arc-elf32-g++",
OBJCOPY="arc-elf32-objcopy",
RANLIB="arc-elf32-ranlib",
SIZETOOL="arc-elf32-size",
ARFLAGS=["rcs"],
ASFLAGS=["-x", "assembler-with-cpp"],
CCFLAGS=[
"-g",
"-Os",
"-ffunction-sections",
"-fdata-sections",
"-Wall",
"-mav2em",
"-mlittle-endian",
"-m${BOARD_OPTIONS['build']['mcu']}",
"-fno-reorder-functions",
"-fno-asynchronous-unwind-tables",
"-fno-omit-frame-pointer",
"-fno-defer-pop",
"-Wno-unused-but-set-variable",
"-Wno-main",
"-ffreestanding",
"-fno-stack-protector",
"-mno-sdata",
"-fsigned-char"
],
CXXFLAGS=[
"-fno-rtti",
"-std=c++11",
"-fno-exceptions"
],
CPPDEFINES=[
"F_CPU=$BOARD_F_CPU",
"ARDUINO_ARC32_TOOLS",
"__CPU_ARC__",
"CLOCK_SPEED=%d" % (
int(env.subst("${BOARD_OPTIONS['build']['f_cpu']}").replace(
"L", ""))/1000000),
"CONFIG_SOC_GPIO_32",
"CONFIG_SOC_GPIO_AON",
"INFRA_MULTI_CPU_SUPPORT",
"CFW_MULTI_CPU_SUPPORT",
"HAS_SHARED_MEM"
],
LINKFLAGS=[
"-Os",
"-Wl,--gc-sections",
"-Wl,-X",
"-Wl,-N",
"-Wl,-m${BOARD_OPTIONS['build']['mcu']}",
"-Wl,-marcelf",
"-static",
"-nostdlib",
"-nodefaultlibs",
"-nostartfiles",
"-Wl,--whole-archive",
"-larc32drv_arduino101",
"-Wl,--no-whole-archive"
],
LIBS=["c", "m", "gcc"],
SIZEPRINTCMD='"$SIZETOOL" -B -d $SOURCES',
UPLOADER=join("$PIOPACKAGES_DIR", "tool-arduino101load", "arduino101load"),
DFUUTIL=join("$PIOPACKAGES_DIR", "tool-arduino101load", "dfu-util"),
UPLOADCMD='"$UPLOADER" $DFUUTIL $SOURCES $UPLOADERFLAGS verbose',
PROGNAME="firmware",
PROGSUFFIX=".elf"
)
env.Append(
ASFLAGS=env.get("CCFLAGS", [])[:],
BUILDERS=dict(
ElfToBin=Builder(
action=" ".join([
"$OBJCOPY",
"-S",
"-O",
"binary",
"-R",
".note",
"-R",
".comment",
"-R",
"COMMON",
"-R",
".eh_frame",
"$SOURCES",
"$TARGET"]),
suffix=".bin"
),
ElfToHex=Builder(
action=" ".join([
"$OBJCOPY",
"-S",
"-O",
"binary",
"-R",
".note",
"-R",
".comment",
"-R",
"COMMON",
"-R",
".eh_frame",
"$SOURCES",
"$TARGET"]),
suffix=".hex"
)
)
)
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Target: Build the .bin
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.bin")
else:
target_firm = env.ElfToBin(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload firmware
#
upload = env.Alias(
["upload", "uploadlazy"], target_firm, [BeforeUpload, "$UPLOADCMD"])
AlwaysBuild(upload)
#
# Target: Define targets
#
Default([target_firm, target_size])

149
platformio/builder/scripts/lattice_ice40.py
View File

@ -1,149 +0,0 @@
"""
Build script for lattice ice40 FPGAs
latticeice40-builder.py
"""
import os
from os.path import join
from SCons.Script import (COMMAND_LINE_TARGETS, AlwaysBuild, Builder, Default,
DefaultEnvironment, Environment, Exit, GetOption,
Glob)
env = DefaultEnvironment()
env.Replace(PROGNAME="hardware")
env.Append(SIMULNAME="simulation")
# -- Get the local folder in which the icestorm tools should be installed
piopackages_dir = env.subst('$PIOPACKAGES_DIR')
bin_dir = join(piopackages_dir, 'toolchain-icestorm', 'bin')
# -- Add this path to the PATH env variable. First the building tools will be
# -- searched in the local PATH. If they are not founde, the global ones will
# -- be executed (if installed)
env.PrependENVPath('PATH', bin_dir)
# -- Target name for synthesis
TARGET = join(env['BUILD_DIR'], env['PROGNAME'])
# -- Target name for simulation
# TARGET_SIM = join(env['PROJECT_DIR'], env['SIMULNAME'])
# -- Get a list of all the verilog files in the src folfer, in ASCII, with
# -- the full path. All these files are used for the simulation
v_nodes = Glob(join(env['PROJECTSRC_DIR'], '*.v'))
src_sim = [str(f) for f in v_nodes]
# --------- Get the Testbench file (there should be only 1)
# -- Create a list with all the files finished in _tb.v. It should contain
# -- the test bench
list_tb = [f for f in src_sim if f[-5:].upper() == "_TB.V"]
if len(list_tb) > 1:
print "---> WARNING: More than one testbenches used"
# -- Error checking
try:
testbench = list_tb[0]
# -- there is no testbench
except IndexError:
testbench = None
if 'sim' in COMMAND_LINE_TARGETS:
if testbench is None:
print "ERROR!!! NO testbench found for simulation"
Exit(1)
# -- Simulation name
testbench_file = os.path.split(testbench)[-1]
SIMULNAME, ext = os.path.splitext(testbench_file)
else:
SIMULNAME = ''
TARGET_SIM = join(env.subst('$BUILD_DIR'), SIMULNAME)
# -------- Get the synthesis files. They are ALL the files except the
# -------- testbench
src_synth = [f for f in src_sim if f not in list_tb]
# -- For debugging
print "Testbench: %s" % testbench
# -- Get the PCF file
src_dir = env.subst('$PROJECTSRC_DIR')
PCFs = join(src_dir, '*.pcf')
PCF_list = Glob(PCFs)
try:
PCF = PCF_list[0]
except IndexError:
print "\n--------> ERROR: no .pcf file found <----------\n"
Exit(2)
# -- Debug
print "----> PCF Found: %s" % PCF
# -- Builder 1 (.v --> .blif)
synth = Builder(action='yosys -p \"synth_ice40 -blif %s.blif\" \
$SOURCES' % TARGET,
suffix='.blif',
src_suffix='.v')
# -- Builder 2 (.blif --> .asc)
pnr = Builder(action='arachne-pnr -d 1k -o $TARGET -p %s \
$SOURCE' % PCF,
suffix='.asc',
src_suffix='.blif')
# -- Builder 3 (.asc --> .bin)
bitstream = Builder(action='icepack $SOURCE $TARGET',
suffix='.bin',
src_suffix='.asc')
# -- Builder 4 (.asc --> .rpt)
time_rpt = Builder(action='icetime -mtr $TARGET $SOURCE',
suffix='.rpt',
src_suffix='.asc')
env.Append(BUILDERS={'Synth': synth, 'PnR': pnr, 'Bin': bitstream,
'Time': time_rpt})
blif = env.Synth(TARGET, [src_synth])
asc = env.PnR(TARGET, [blif, PCF])
binf = env.Bin(TARGET, asc)
upload = env.Alias('upload', binf, 'iceprog ' + ' $SOURCE')
AlwaysBuild(upload)
# -- Target for calculating the time (.rpt)
# rpt = env.Time(asc)
t = env.Alias('time', env.Time('time.rpt', asc))
# -------------------- Simulation ------------------
# -- Constructor para generar simulacion: icarus Verilog
iverilog = Builder(action='iverilog -o $TARGET $SOURCES ',
suffix='.out',
src_suffix='.v')
vcd = Builder(action=' $SOURCE',
suffix='.vcd', src_suffix='.out')
simenv = Environment(BUILDERS={'IVerilog': iverilog, 'VCD': vcd},
ENV=os.environ)
out = simenv.IVerilog(TARGET_SIM, src_sim)
vcd_file = simenv.VCD(SIMULNAME, out)
waves = simenv.Alias('sim', vcd_file, 'gtkwave ' +
join(env['PROJECT_DIR'], "%s " % vcd_file[0]) +
join(env['PROJECTSRC_DIR'], SIMULNAME) +
'.gtkw')
AlwaysBuild(waves)
Default([binf])
# -- These is for cleaning the files generated using the alias targets
if GetOption('clean'):
env.Default([t])
simenv.Default([out, vcd_file])

60
platformio/builder/scripts/linux_arm.py
View File

@ -1,60 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for Linux ARM
"""
from SCons.Script import AlwaysBuild, Default, DefaultEnvironment
from platformio.util import get_systype
env = DefaultEnvironment()
env.Replace(
_BINPREFIX="",
AR="${_BINPREFIX}ar",
AS="${_BINPREFIX}as",
CC="${_BINPREFIX}gcc",
CXX="${_BINPREFIX}g++",
OBJCOPY="${_BINPREFIX}objcopy",
RANLIB="${_BINPREFIX}ranlib",
SIZETOOL="${_BINPREFIX}size",
SIZEPRINTCMD='"$SIZETOOL" $SOURCES'
)
if get_systype() == "darwin_x86_64":
env.Replace(
_BINPREFIX="arm-linux-gnueabihf-"
)
#
# Target: Build executable program
#
target_bin = env.BuildProgram()
#
# Target: Print binary size
#
target_size = env.Alias("size", target_bin, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Define targets
#
Default([target_bin])

60
platformio/builder/scripts/linux_i686.py
View File

@ -1,60 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for Linux Linux i686 / 32-bit
"""
from SCons.Script import AlwaysBuild, Default, DefaultEnvironment
from platformio.util import get_systype
env = DefaultEnvironment()
env.Replace(
_BINPREFIX="",
AR="${_BINPREFIX}ar",
AS="${_BINPREFIX}as",
CC="${_BINPREFIX}gcc",
CXX="${_BINPREFIX}g++",
OBJCOPY="${_BINPREFIX}objcopy",
RANLIB="${_BINPREFIX}ranlib",
SIZETOOL="${_BINPREFIX}size",
SIZEPRINTCMD='"$SIZETOOL" $SOURCES'
)
if get_systype() == "darwin_x86_64":
env.Replace(
_BINPREFIX="i586-pc-linux-"
)
#
# Target: Build executable program
#
target_bin = env.BuildProgram()
#
# Target: Print binary size
#
target_size = env.Alias("size", target_bin, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Define targets
#
Default([target_bin])

60
platformio/builder/scripts/linux_x86_64.py
View File

@ -1,60 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for Linux Linux x64_64 / 64-bit
"""
from SCons.Script import AlwaysBuild, Default, DefaultEnvironment
from platformio.util import get_systype
env = DefaultEnvironment()
env.Replace(
_BINPREFIX="",
AR="${_BINPREFIX}ar",
AS="${_BINPREFIX}as",
CC="${_BINPREFIX}gcc",
CXX="${_BINPREFIX}g++",
OBJCOPY="${_BINPREFIX}objcopy",
RANLIB="${_BINPREFIX}ranlib",
SIZETOOL="${_BINPREFIX}size",
SIZEPRINTCMD='"$SIZETOOL" $SOURCES'
)
if get_systype() == "darwin_x86_64":
env.Replace(
_BINPREFIX="x86_64-pc-linux-"
)
#
# Target: Build executable program
#
target_bin = env.BuildProgram()
#
# Target: Print binary size
#
target_size = env.Alias("size", target_bin, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Define targets
#
Default([target_bin])

190
platformio/builder/scripts/microchippic32.py
View File

@ -1,190 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for Microchip PIC32 microcontrollers
"""
from os.path import join
from SCons.Script import (COMMAND_LINE_TARGETS, AlwaysBuild, Builder, Default,
DefaultEnvironment)
def BeforeUpload(target, source, env): # pylint: disable=W0613,W0621
env.AutodetectUploadPort()
env.Prepend(UPLOADERFLAGS=["-d", '"$UPLOAD_PORT"'])
env = DefaultEnvironment()
env.Replace(
AR="pic32-ar",
AS="pic32-as",
CC="pic32-gcc",
CXX="pic32-g++",
OBJCOPY="pic32-objcopy",
RANLIB="pic32-ranlib",
SIZETOOL="pic32-size",
ARFLAGS=["rcs"],
ASFLAGS=[
"-g1",
"-O2",
"-Wa,--gdwarf-2",
"-mprocessor=$BOARD_MCU"
],
CCFLAGS=[
"-w",
"-g",
"-O2",
"-MMD",
"-mdebugger",
"-mno-smart-io",
"-mprocessor=$BOARD_MCU",
"-ffunction-sections",
"-fdata-sections",
"-Wcast-align",
"-fno-short-double",
"-ftoplevel-reorder"
],
CXXFLAGS=["-fno-exceptions"],
CPPDEFINES=[
"F_CPU=$BOARD_F_CPU",
"MPIDEVER=16777998",
"MPIDE=150"
],
LINKFLAGS=[
"-w",
"-Os",
"-mdebugger",
"-mprocessor=$BOARD_MCU",
"-mno-peripheral-libs",
"-nostartfiles",
"-Wl,--gc-sections"
],
LIBS=["m"],
SIZEPRINTCMD='"$SIZETOOL" -B -d $SOURCES',
UPLOADER=join("$PIOPACKAGES_DIR", "tool-pic32prog", "pic32prog"),
UPLOADERFLAGS=[
"-b", "$UPLOAD_SPEED"
],
UPLOADCMD='"$UPLOADER" $UPLOADERFLAGS $SOURCES',
PROGNAME="firmware",
PROGSUFFIX=".elf"
)
if int(env.get("BOARD_OPTIONS", {}).get(
"upload", {}).get("maximum_ram_size", 0)) < 65535:
env.Append(
CCFLAGS=["-G1024"]
)
env.Append(
BUILDERS=dict(
ElfToEep=Builder(
action=" ".join([
"$OBJCOPY",
"-O",
"ihex",
"-j",
".eeprom",
'--set-section-flags=.eeprom="alloc,load"',
"--no-change-warnings",
"--change-section-lma",
".eeprom=0",
"$SOURCES",
"$TARGET"]),
suffix=".eep"
),
ElfToHex=Builder(
action=" ".join([
"$OBJCOPY",
"-O",
"ihex",
"-R",
".eeprom",
"$SOURCES",
"$TARGET"]),
suffix=".hex"
)
)
)
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Hook: Fix option for LD script
#
_new_linkflags = []
for f in env['LINKFLAGS']:
if not f.startswith("-Wl,-T"):
_new_linkflags.append(f)
else:
_new_linkflags.append("-Wl,--script=%s" % f[6:])
env.Replace(LINKFLAGS=_new_linkflags)
env.Append(
LINKFLAGS=[
"-Wl,--script=chipKIT-application-COMMON%s.ld" % (
"-MZ" if "MZ" in env.get("BOARD_OPTIONS", {}).get(
"build", {}).get("mcu") else "")
]
)
#
# Target: Build the .hex
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.hex")
else:
target_firm = env.ElfToHex(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload firmware
#
upload = env.Alias(
["upload", "uploadlazy"], target_firm, [BeforeUpload, "$UPLOADCMD"])
AlwaysBuild(upload)
#
# Target: Define targets
#
Default([target_firm, target_size])

44
platformio/builder/scripts/native.py
View File

@ -1,44 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for native platform
"""
from SCons.Script import AlwaysBuild, Default, DefaultEnvironment
env = DefaultEnvironment()
env.Replace(
SIZEPRINTCMD="size $SOURCES"
)
#
# Target: Build executable program
#
target_bin = env.BuildProgram()
#
# Target: Print binary size
#
target_size = env.Alias("size", target_bin, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Define targets
#
Default([target_bin])

77
platformio/builder/scripts/nordicnrf51.py
View File

@ -1,77 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for Nordic nRF51 series ARM microcontrollers.
"""
from os.path import join
from SCons.Script import (COMMAND_LINE_TARGETS, AlwaysBuild, Default,
DefaultEnvironment, SConscript)
env = DefaultEnvironment()
SConscript(env.subst(join("$PIOBUILDER_DIR", "scripts", "basearm.py")))
if env.subst("$BOARD") == "rfduino":
env.Append(
CCFLAGS=["-fno-builtin"],
LINKFLAGS=["--specs=nano.specs"]
)
env.Replace(
UPLOADER=join("$PIOPACKAGES_DIR", "tool-rfdloader", "rfdloader"),
UPLOADERFLAGS=["-q", '"$UPLOAD_PORT"'],
UPLOADCMD='"$UPLOADER" $UPLOADERFLAGS $SOURCES'
)
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Target: Build the .bin file
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.hex")
else:
target_firm = env.ElfToHex(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload by default .bin file
#
if env.subst("$BOARD") == "rfduino":
upload = env.Alias(
["upload", "uploadlazy"], target_firm,
[lambda target, source, env: env.AutodetectUploadPort(), "$UPLOADCMD"])
else:
upload = env.Alias(["upload", "uploadlazy"], target_firm, env.UploadToDisk)
AlwaysBuild(upload)
#
# Target: Define targets
#
Default([target_firm, target_size])

70
platformio/builder/scripts/nxplpc.py
View File

@ -1,70 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for NXP LPC series ARM microcontrollers.
"""
from os.path import join
from shutil import copyfile
from SCons.Script import (COMMAND_LINE_TARGETS, AlwaysBuild, Default,
DefaultEnvironment, SConscript)
def UploadToDisk(target, source, env): # pylint: disable=W0613,W0621
env.AutodetectUploadPort()
copyfile(join(env.subst("$BUILD_DIR"), "firmware.bin"),
join(env.subst("$UPLOAD_PORT"), "firmware.bin"))
print("Firmware has been successfully uploaded.\n"
"Please restart your board.")
env = DefaultEnvironment()
SConscript(env.subst(join("$PIOBUILDER_DIR", "scripts", "basearm.py")))
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Target: Build the .bin file
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.bin")
else:
target_firm = env.ElfToBin(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload by default .bin file
#
upload = env.Alias(["upload", "uploadlazy"], target_firm, UploadToDisk)
AlwaysBuild(upload)
#
# Target: Define targets
#
Default([target_firm, target_size])

61
platformio/builder/scripts/siliconlabsefm32.py
View File

@ -1,61 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for Silicon Labs EFM32 series ARM microcontrollers.
"""
from os.path import join
from SCons.Script import (COMMAND_LINE_TARGETS, AlwaysBuild, Default,
DefaultEnvironment, SConscript)
env = DefaultEnvironment()
SConscript(env.subst(join("$PIOBUILDER_DIR", "scripts", "basearm.py")))
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Target: Build the .bin file
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.bin")
else:
target_firm = env.ElfToBin(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload by default .bin file
#
upload = env.Alias(["upload", "uploadlazy"], target_firm, env.UploadToDisk)
AlwaysBuild(upload)
#
# Target: Define targets
#
Default([target_firm, target_size])

113
platformio/builder/scripts/ststm32.py
View File

@ -1,113 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for ST STM32 Series ARM microcontrollers.
"""
from os.path import isfile, join
from SCons.Script import (COMMAND_LINE_TARGETS, AlwaysBuild, Default,
DefaultEnvironment, SConscript)
env = DefaultEnvironment()
SConscript(env.subst(join("$PIOBUILDER_DIR", "scripts", "basearm.py")))
if env.subst("$UPLOAD_PROTOCOL") == "gdb":
if not isfile(join(env.subst("$PROJECT_DIR"), "upload.gdb")):
env.Exit(
"Error: You are using GDB as firmware uploader. "
"Please specify upload commands in upload.gdb "
"file in project directory!"
)
env.Replace(
UPLOADER=join(
"$PIOPACKAGES_DIR", "toolchain-gccarmnoneeabi",
"bin", "arm-none-eabi-gdb"
),
UPLOADERFLAGS=[
join("$BUILD_DIR", "firmware.elf"),
"-batch",
"-x",
'"%s"' % join("$PROJECT_DIR", "upload.gdb")
],
UPLOADCMD='"$UPLOADER" $UPLOADERFLAGS'
)
else:
env.Replace(
UPLOADER=join("$PIOPACKAGES_DIR", "tool-stlink", "st-flash"),
UPLOADERFLAGS=[
"write", # write in flash
"$SOURCES", # firmware path to flash
"0x08000000" # flash start adress
],
UPLOADCMD='"$UPLOADER" $UPLOADERFLAGS'
)
env.Append(
CPPDEFINES=[
env.get("BOARD_OPTIONS", {}).get(
"build", {}).get("variant", "").upper()
],
LIBS=["stdc++", "nosys"],
LINKFLAGS=[
"-nostartfiles",
"-nostdlib"
]
)
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Target: Build the .bin file
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.bin")
else:
target_firm = env.ElfToBin(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload by default .bin file
#
if "mbed" in env.subst("$FRAMEWORK") and not env.subst("$UPLOAD_PROTOCOL"):
upload = env.Alias(["upload", "uploadlazy"],
target_firm, env.UploadToDisk)
else:
upload = env.Alias(["upload", "uploadlazy"], target_firm, "$UPLOADCMD")
AlwaysBuild(upload)
#
# Target: Define targets
#
Default([target_firm, target_size])

115
platformio/builder/scripts/teensy.py
View File

@ -1,115 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for Teensy boards
"""
from os.path import isfile, join
from SCons.Script import (COMMAND_LINE_TARGETS, AlwaysBuild, Default,
DefaultEnvironment, SConscript)
env = DefaultEnvironment()
if env.get("BOARD_OPTIONS", {}).get("build", {}).get("core") == "teensy":
SConscript(env.subst(join("$PIOBUILDER_DIR", "scripts", "baseavr.py")))
elif env.get("BOARD_OPTIONS", {}).get("build", {}).get("core") == "teensy3":
SConscript(env.subst(join("$PIOBUILDER_DIR", "scripts", "basearm.py")))
env.Append(
LINKFLAGS=[
"-Wl,--defsym=__rtc_localtime=$UNIX_TIME",
"-fsingle-precision-constant",
"--specs=nano.specs"
],
CCFLAGS=[
"-fsingle-precision-constant"
]
)
env.Append(
CPPDEFINES=[
"USB_SERIAL",
"LAYOUT_US_ENGLISH"
],
CXXFLAGS=[
"-std=gnu++0x",
"-felide-constructors"
]
)
if isfile(env.subst(join(
"$PIOPACKAGES_DIR", "tool-teensy", "teensy_loader_cli"))):
env.Append(
UPLOADER=join(
"$PIOPACKAGES_DIR", "tool-teensy", "teensy_loader_cli"),
UPLOADERFLAGS=[
"-mmcu=$BOARD_MCU",
"-w", # wait for device to apear
"-s", # soft reboot if device not online
"-v" # verbose output
],
UPLOADHEXCMD='"$UPLOADER" $UPLOADERFLAGS $SOURCES'
)
else:
env.Append(
REBOOTER=join(
"$PIOPACKAGES_DIR", "tool-teensy", "teensy_reboot"),
UPLOADER=join(
"$PIOPACKAGES_DIR", "tool-teensy", "teensy_post_compile"),
UPLOADERFLAGS=[
"-file=firmware",
'-path="$BUILD_DIR"',
'-tools="%s"' % join("$PIOPACKAGES_DIR", "tool-teensy")
],
UPLOADHEXCMD='"$UPLOADER" $UPLOADERFLAGS'
)
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Target: Build the firmware file
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.hex")
else:
target_firm = env.ElfToHex(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload by default firmware file
#
upload = env.Alias(
["upload", "uploadlazy"], target_firm,
["$UPLOADHEXCMD"] + (["$REBOOTER"] if "REBOOTER" in env else []))
AlwaysBuild(upload)
#
# Target: Define targets
#
Default([target_firm, target_size])

127
platformio/builder/scripts/timsp430.py
View File

@ -1,127 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for Texas Instruments
MSP430 Ultra-Low Power 16-bit microcontrollers
"""
from os.path import join
from platform import system
from SCons.Script import (COMMAND_LINE_TARGETS, AlwaysBuild, Builder, Default,
DefaultEnvironment)
env = DefaultEnvironment()
env.Replace(
AR="msp430-ar",
AS="msp430-as",
CC="msp430-gcc",
CXX="msp430-g++",
OBJCOPY="msp430-objcopy",
RANLIB="msp430-ranlib",
SIZETOOL="msp430-size",
ARFLAGS=["rcs"],
ASFLAGS=["-x", "assembler-with-cpp"],
CCFLAGS=[
"-g", # include debugging info (so errors include line numbers)
"-Os", # optimize for size
# "-Wall", # show warnings
"-ffunction-sections", # place each function in its own section
"-fdata-sections",
"-mmcu=$BOARD_MCU"
],
CPPDEFINES=[
"F_CPU=$BOARD_F_CPU"
],
LINK="$CC",
LINKFLAGS=[
"-Os",
"-mmcu=$BOARD_MCU",
"-Wl,-gc-sections,-u,main"
],
LIBS=["m"],
SIZEPRINTCMD='"$SIZETOOL" -B -d $SOURCES',
UPLOADER=join("$PIOPACKAGES_DIR", "tool-mspdebug", "mspdebug"),
UPLOADERFLAGS=[
"$UPLOAD_PROTOCOL" if system() != "Windows" else "tilib",
"--force-reset"
],
UPLOADCMD='"$UPLOADER" $UPLOADERFLAGS "prog $SOURCES"',
PROGNAME="firmware",
PROGSUFFIX=".elf"
)
env.Append(
ASFLAGS=env.get("CCFLAGS", [])[:],
BUILDERS=dict(
ElfToHex=Builder(
action=" ".join([
"$OBJCOPY",
"-O",
"ihex",
"-R",
".eeprom",
"$SOURCES",
"$TARGET"]),
suffix=".hex"
)
)
)
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Target: Build the .hex
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.hex")
else:
target_firm = env.ElfToHex(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload firmware
#
upload = env.Alias(["upload", "uploadlazy"], target_firm, "$UPLOADCMD")
AlwaysBuild(upload)
#
# Target: Define targets
#
Default([target_firm, target_size])

74
platformio/builder/scripts/titiva.py
View File

@ -1,74 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for Texas Instruments
Tiva C Series ARM Cortex-M4 microcontrollers.
"""
from os.path import join
from SCons.Script import (COMMAND_LINE_TARGETS, AlwaysBuild, Default,
DefaultEnvironment, SConscript)
env = DefaultEnvironment()
SConscript(env.subst(join("$PIOBUILDER_DIR", "scripts", "basearm.py")))
env.Replace(
UPLOADER=join("$PIOPACKAGES_DIR", "tool-lm4flash", "lm4flash"),
UPLOADCMD='"$UPLOADER" $SOURCES'
)
env.Append(
LINKFLAGS=[
"-nostartfiles",
"-nostdlib"
]
)
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Target: Build the .bin file
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.bin")
else:
target_firm = env.ElfToBin(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload firmware
#
upload = env.Alias(["upload", "uploadlazy"], target_firm, "$UPLOADCMD")
AlwaysBuild(upload)
#
# Target: Define targets
#
Default([target_firm, target_size])

65
platformio/builder/scripts/windows_x86.py
View File

@ -1,65 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Builder for Windows x86 / 32bit
"""
from SCons.Script import AlwaysBuild, Default, DefaultEnvironment
from platformio.util import get_systype
env = DefaultEnvironment()
env.Replace(
_BINPREFIX="",
AR="${_BINPREFIX}ar",
AS="${_BINPREFIX}as",
CC="${_BINPREFIX}gcc",
CXX="${_BINPREFIX}g++",
OBJCOPY="${_BINPREFIX}objcopy",
RANLIB="${_BINPREFIX}ranlib",
SIZETOOL="${_BINPREFIX}size",
SIZEPRINTCMD='"$SIZETOOL" $SOURCES',
PROGSUFFIX=".exe"
)
if get_systype() == "darwin_x86_64":
env.Replace(
_BINPREFIX="i586-mingw32-"
)
elif get_systype() in ("linux_x86_64", "linux_i686"):
env.Replace(
_BINPREFIX="i686-w64-mingw32-"
)
#
# Target: Build executable program
#
target_bin = env.BuildProgram()
#
# Target: Print binary size
#
target_size = env.Alias("size", target_bin, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Define targets
#
Default([target_bin])

0
platformio/commands/platforms.py → platformio/commands/platform.py
View File

0
platformio/pkgmanager.py → platformio/managers/package.py
View File

0
platformio/platforms/base.py → platformio/managers/platform.py
View File

13
platformio/platforms/__init__.py
View File

@ -1,13 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

74
platformio/platforms/atmelavr.py
View File

@ -1,74 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
from platformio.util import get_boards
class AtmelavrPlatform(BasePlatform):
"""
Atmel AVR 8- and 32-bit MCUs deliver a unique combination of
performance, power efficiency and design flexibility. Optimized to
speed time to market-and easily adapt to new ones-they are based on
the industrys most code-efficient architecture for C and assembly
programming.
http://www.atmel.com/products/microcontrollers/avr/default.aspx
"""
PACKAGES = {
"toolchain-atmelavr": {
"alias": "toolchain",
"default": True
},
"tool-avrdude": {
"alias": "uploader"
},
"tool-micronucleus": {
"alias": "uploader"
},
"framework-arduinoavr": {
"alias": "framework"
},
"framework-simba": {
"alias": "framework"
}
}
def get_name(self):
return "Atmel AVR"
def configure_default_packages(self, envoptions, targets):
if envoptions.get("board"):
board = get_boards(envoptions.get("board"))
disable_tool = "tool-micronucleus"
if "digispark" in board['build']['core']:
disable_tool = "tool-avrdude"
del self.PACKAGES[disable_tool]['alias']
return BasePlatform.configure_default_packages(
self, envoptions, targets)
def on_run_err(self, line): # pylint: disable=R0201
# fix STDERR "flash written" for avrdude
if "avrdude" in line:
self.on_run_out(line)
else:
BasePlatform.on_run_err(self, line)

61
platformio/platforms/atmelsam.py
View File

@ -1,61 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
class AtmelsamPlatform(BasePlatform):
"""
Atmel | SMART offers Flash- based ARM products based on the ARM
Cortex-M0+, Cortex-M3 and Cortex-M4 architectures, ranging from 8KB
to 2MB of Flash including a rich peripheral and feature mix.
http://www.atmel.com/products/microcontrollers/arm/default.aspx
"""
PACKAGES = {
"toolchain-gccarmnoneeabi": {
"alias": "toolchain",
"default": True
},
"ldscripts": {
"default": True
},
"framework-arduinosam": {
"alias": "framework"
},
"framework-mbed": {
"alias": "framework"
},
"framework-simba": {
"alias": "framework"
},
"tool-bossac": {
"alias": "uploader"
},
"tool-openocd": {
"alias": "uploader"
}
}
def get_name(self):
return "Atmel SAM"

68
platformio/platforms/espressif.py
View File

@ -1,68 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
class EspressifPlatform(BasePlatform):
"""
Espressif Systems is a privately held fabless semiconductor company.
They provide wireless communications and Wi-Fi chips which are widely
used in mobile devices and the Internet of Things applications.
https://espressif.com/
"""
PACKAGES = {
"toolchain-xtensa": {
"alias": "toolchain",
"default": True
},
"ldscripts": {
"default": True
},
"tool-esptool": {
"alias": "uploader",
"default": True
},
"tool-mkspiffs": {
"alias": "uploader"
},
"sdk-esp8266": {
},
"framework-arduinoespressif": {
"alias": "framework"
},
"framework-simba": {
"alias": "framework"
}
}
def get_name(self):
return "Espressif"
def configure_default_packages(self, envoptions, targets):
if not envoptions.get("framework"):
self.PACKAGES['sdk-esp8266']['default'] = True
return BasePlatform.configure_default_packages(
self, envoptions, targets)

42
platformio/platforms/freescalekinetis.py
View File

@ -1,42 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
class FreescalekinetisPlatform(BasePlatform):
"""
Freescale Kinetis Microcontrollers is family of multiple hardware- and
software-compatible ARM Cortex-M0+, Cortex-M4 and Cortex-M7-based MCU
series. Kinetis MCUs offer exceptional low-power performance,
scalability and feature integration.
http://www.freescale.com/webapp/sps/site/homepage.jsp?code=KINETIS
"""
PACKAGES = {
"toolchain-gccarmnoneeabi": {
"alias": "toolchain",
"default": True
},
"framework-mbed": {
"alias": "framework"
}
}
def get_name(self):
return "Freescale Kinetis"

45
platformio/platforms/intel_arc32.py
View File

@ -1,45 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
class Intel_arc32Platform(BasePlatform):
"""
ARC embedded processors are a family of 32-bit CPUs that are widely used
in SoC devices for storage, home, mobile, automotive, and Internet of
Things applications.
http://www.intel.com/content/www/us/en/wearables/wearable-soc.html
"""
PACKAGES = {
"toolchain-intelarc32": {
"alias": "toolchain",
"default": True
},
"framework-arduinointel": {
"alias": "framework"
},
"tool-arduino101load": {
"alias": "uploader"
},
}
def get_name(self):
return "Intel ARC32"

43
platformio/platforms/lattice_ice40.py
View File

@ -1,43 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
class Lattice_ice40Platform(BasePlatform):
"""
The iCE40 family of ultra-low power, non-volatile FPGAs has five devices
with densities ranging from 384 to 7680 Look-Up Tables (LUTs). In addition
to LUT-based,low-cost programmable logic, these devices feature Embedded
Block RAM (EBR), Non-volatile Configuration Memory (NVCM) and Phase Locked
Loops (PLLs). These features allow the devices to be used in low-cost,
high-volume consumer and system applications.
http://www.latticesemi.com/Products/FPGAandCPLD/iCE40.aspx
"""
PACKAGES = {
"toolchain-icestorm": {
"alias": "toolchain",
"default": True
}
}
def get_name(self):
return "Lattice iCE40"
def is_embedded(self):
return True

59
platformio/platforms/linux_arm.py
View File

@ -1,59 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio import exception, util
from platformio.platforms.base import BasePlatform
class Linux_armPlatform(BasePlatform):
"""
Linux ARM is a Unix-like and mostly POSIX-compliant computer
operating system (OS) assembled under the model of free and open-source
software development and distribution.
Using host OS (Mac OS X, Linux ARM) you can build native application
for Linux ARM platform.
http://platformio.org/platforms/linux_arm
"""
PACKAGES = {
"toolchain-gccarmlinuxgnueabi": {
"alias": "toolchain",
"default": True
},
"framework-wiringpi": {
"alias": "framework"
}
}
def __init__(self):
if "linux_arm" in util.get_systype():
del self.PACKAGES['toolchain-gccarmlinuxgnueabi']
BasePlatform.__init__(self)
def configure_default_packages(self, envoptions, targets):
if (envoptions.get("framework") == "wiringpi" and
"linux_arm" not in util.get_systype()):
raise exception.PlatformioException(
"PlatformIO does not support temporary cross-compilation "
"for WiringPi framework. Please run PlatformIO directly on "
"Raspberry Pi"
)
return BasePlatform.configure_default_packages(
self, envoptions, targets)

43
platformio/platforms/linux_i686.py
View File

@ -1,43 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
from platformio.util import get_systype
class Linux_i686Platform(BasePlatform):
"""
Linux i686 (32-bit) is a Unix-like and mostly POSIX-compliant
computer operating system (OS) assembled under the model of free and
open-source software development and distribution.
Using host OS (Mac OS X or Linux 32-bit) you can build native
application for Linux i686 platform.
http://platformio.org/platforms/linux_i686
"""
PACKAGES = {
"toolchain-gcclinux32": {
"alias": "toolchain",
"default": True
}
}
def __init__(self):
if get_systype() == "linux_i686":
del self.PACKAGES['toolchain-gcclinux32']
BasePlatform.__init__(self)

43
platformio/platforms/linux_x86_64.py
View File

@ -1,43 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
from platformio.util import get_systype
class Linux_x86_64Platform(BasePlatform):
"""
Linux x86_64 (64-bit) is a Unix-like and mostly POSIX-compliant
computer operating system (OS) assembled under the model of free and
open-source software development and distribution.
Using host OS (Mac OS X or Linux 64-bit) you can build native
application for Linux x86_64 platform.
http://platformio.org/platforms/linux_i686
"""
PACKAGES = {
"toolchain-gcclinux64": {
"alias": "toolchain",
"default": True
}
}
def __init__(self):
if get_systype() == "linux_x86_64":
del self.PACKAGES['toolchain-gcclinux64']
BasePlatform.__init__(self)

46
platformio/platforms/microchippic32.py
View File

@ -1,46 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
class Microchippic32Platform(BasePlatform):
"""
Microchip's 32-bit portfolio with the MIPS microAptiv or M4K core offer
high performance microcontrollers, and all the tools needed to develop
your embedded projects. PIC32 MCUs gives your application the processing
power, memory and peripherals your design needs!
http://www.microchip.com/design-centers/32-bit
"""
PACKAGES = {
"toolchain-microchippic32": {
"alias": "toolchain",
"default": True
},
"framework-arduinomicrochippic32": {
"alias": "framework"
},
"tool-pic32prog": {
"alias": "uploader"
}
}
def get_name(self):
return "Microchip PIC32"

29
platformio/platforms/native.py
View File

@ -1,29 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
class NativePlatform(BasePlatform):
"""
Native development platform is intended to be used for desktop OS.
This platform uses built-in toolchains (preferable based on GCC),
frameworks, libs from particular OS where it will be run.
http://platformio.org/platforms/native
"""
PACKAGES = {
}

58
platformio/platforms/nordicnrf51.py
View File

@ -1,58 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
class Nordicnrf51Platform(BasePlatform):
"""
The Nordic nRF51 Series is a family of highly flexible,
multi-protocol, system-on-chip (SoC) devices for ultra-low power
wireless applications. nRF51 Series devices support a range of
protocol stacks including Bluetooth Smart (previously called
Bluetooth low energy), ANT and proprietary 2.4GHz protocols such as
Gazell.
https://www.nordicsemi.com/eng/Products/nRF51-Series-SoC
"""
PACKAGES = {
"toolchain-gccarmnoneeabi": {
"alias": "toolchain",
"default": True
},
"framework-mbed": {
"alias": "framework"
},
"framework-arduinonordicnrf51": {
"alias": "framework"
},
"tool-rfdloader": {
}
}
def get_name(self):
return "Nordic nRF51"
def configure_default_packages(self, envoptions, targets):
if envoptions.get("board") == "rfduino":
self.PACKAGES['tool-rfdloader']['alias'] = "uploader"
return BasePlatform.configure_default_packages(
self, envoptions, targets)

44
platformio/platforms/nxplpc.py
View File

@ -1,44 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
class NxplpcPlatform(BasePlatform):
"""
The NXP LPC is a family of 32-bit microcontroller integrated circuits
by NXP Semiconductors. The LPC chips are grouped into related series
that are based around the same 32-bit ARM processor core, such as the
Cortex-M4F, Cortex-M3, Cortex-M0+, or Cortex-M0. Internally, each
microcontroller consists of the processor core, static RAM memory,
flash memory, debugging interface, and various peripherals.
http://www.nxp.com/products/microcontrollers/
"""
PACKAGES = {
"toolchain-gccarmnoneeabi": {
"alias": "toolchain",
"default": True
},
"framework-mbed": {
"alias": "framework"
}
}
def get_name(self):
return "NXP LPC"

47
platformio/platforms/siliconlabsefm32.py
View File

@ -1,47 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
class Siliconlabsefm32Platform(BasePlatform):
"""
Silicon Labs EFM32 Gecko 32-bit microcontroller (MCU) family includes
devices that offer flash memory configurations up to 256 kB, 32 kB of
RAM and CPU speeds up to 48 MHz.
Based on the powerful ARM Cortex-M core, the Gecko family features
innovative low energy techniques, short wake-up time from energy saving
modes and a wide selection of peripherals, making it ideal for battery
operated applications and other systems requiring high performance and
low-energy consumption.
http://www.silabs.com/products/mcu/32-bit/efm32-gecko/Pages/efm32-gecko.aspx
"""
PACKAGES = {
"toolchain-gccarmnoneeabi": {
"alias": "toolchain",
"default": True
},
"framework-mbed": {
"alias": "framework"
}
}
def get_name(self):
return "Silicon Labs EFM32"

71
platformio/platforms/ststm32.py
View File

@ -1,71 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
class Ststm32Platform(BasePlatform):
"""
The STM32 family of 32-bit Flash MCUs based on the ARM Cortex-M
processor is designed to offer new degrees of freedom to MCU users.
It offers a 32-bit product range that combines very high performance,
real-time capabilities, digital signal processing, and low-power,
low-voltage operation, while maintaining full integration and ease of
development.
http://www.st.com/web/en/catalog/mmc/FM141/SC1169?sc=stm32
"""
PACKAGES = {
"toolchain-gccarmnoneeabi": {
"alias": "toolchain",
"default": True
},
"ldscripts": {
"default": True
},
"tool-stlink": {
"alias": "uploader"
},
"framework-cmsis": {
"alias": "framework"
},
"framework-spl": {
"alias": "framework"
},
"framework-libopencm3": {
"alias": "framework"
},
"framework-mbed": {
"alias": "framework"
}
}
def get_name(self):
return "ST STM32"
def configure_default_packages(self, envoptions, targets):
if envoptions.get("framework") == "cmsis":
self.PACKAGES['framework-mbed']['default'] = True
return BasePlatform.configure_default_packages(
self, envoptions, targets)

69
platformio/platforms/teensy.py
View File

@ -1,69 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
from platformio.util import get_boards
class TeensyPlatform(BasePlatform):
"""
Teensy is a complete USB-based microcontroller development system, in
a very small footprint, capable of implementing many types of projects.
All programming is done via the USB port. No special programmer is
needed, only a standard USB cable and a PC or Macintosh with a USB port.
https://www.pjrc.com/teensy
"""
PACKAGES = {
"toolchain-atmelavr": {
},
"toolchain-gccarmnoneeabi": {
},
"ldscripts": {
"default": True
},
"framework-arduinoteensy": {
"alias": "framework"
},
"framework-mbed": {
"alias": "framework"
},
"tool-teensy": {
"alias": "uploader"
}
}
def get_name(self):
return "Teensy"
def configure_default_packages(self, envoptions, targets):
if envoptions.get("board"):
board = get_boards(envoptions.get("board"))
if board['build']['core'] == "teensy":
name = "toolchain-atmelavr"
else:
name = "toolchain-gccarmnoneeabi"
self.PACKAGES[name]['alias'] = "toolchain"
self.PACKAGES[name]['default'] = True
return BasePlatform.configure_default_packages(
self, envoptions, targets)

50
platformio/platforms/timsp430.py
View File

@ -1,50 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
class Timsp430Platform(BasePlatform):
"""
MSP430 microcontrollers (MCUs) from Texas Instruments (TI)
are 16-bit, RISC-based, mixed-signal processors designed for ultra-low
power. These MCUs offer the lowest power consumption and the perfect
mix of integrated peripherals for thousands of applications.
http://www.ti.com/lsds/ti/microcontrollers_16-bit_32-bit/msp/overview.page
"""
PACKAGES = {
"toolchain-timsp430": {
"alias": "toolchain",
"default": True
},
"tool-mspdebug": {
"alias": "uploader"
},
"framework-energiamsp430": {
"alias": "framework"
},
"framework-arduinomsp430": {
"alias": "framework"
}
}
def get_name(self):
return "TI MSP430"

54
platformio/platforms/titiva.py
View File

@ -1,54 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
class TitivaPlatform(BasePlatform):
"""
Texas Instruments TM4C12x MCUs offer the industrys most popular
ARM Cortex-M4 core with scalable memory and package options, unparalleled
connectivity peripherals, advanced application functions, industry-leading
analog integration, and extensive software solutions.
http://www.ti.com/lsds/ti/microcontrollers_16-bit_32-bit/c2000_performance/control_automation/tm4c12x/overview.page
"""
PACKAGES = {
"toolchain-gccarmnoneeabi": {
"alias": "toolchain",
"default": True
},
"ldscripts": {
"default": True
},
"tool-lm4flash": {
"alias": "uploader"
},
"framework-energiativa": {
"alias": "framework"
},
"framework-libopencm3": {
"alias": "framework"
}
}
def get_name(self):
return "TI TIVA"

35
platformio/platforms/windows_x86.py
View File

@ -1,35 +0,0 @@
# Copyright 2014-2016 Ivan Kravets <me@ikravets.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from platformio.platforms.base import BasePlatform
class Windows_x86Platform(BasePlatform):
"""
Windows x86 (32-bit) is a metafamily of graphical operating systems
developed and marketed by Microsoft.
Using host OS (Windows, Linux 32/64 or Mac OS X) you can build native
application for Windows x86 platform.
http://platformio.org/platforms/windows_x86
"""
PACKAGES = {
"toolchain-gccmingw32": {
"alias": "toolchain",
"default": True
}
}