1.1.x version of Auto-build PR 10503 (#10561)
This commit is contained in:
Bob-the-Kuhn
Scott Lahteine
parent
522ea178a4
commit
382aa96870
183
Marlin/pins.h
183
Marlin/pins.h
|
|
@ -52,217 +52,218 @@
|
|||
//
|
||||
|
||||
#if MB(RAMPS_OLD)
|
||||
#include "pins_RAMPS_OLD.h"
|
||||
#include "pins_RAMPS_OLD.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RAMPS_13_EFB)
|
||||
#include "pins_RAMPS_13.h"
|
||||
#include "pins_RAMPS_13.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RAMPS_13_EEB)
|
||||
#include "pins_RAMPS_13.h"
|
||||
#include "pins_RAMPS_13.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RAMPS_13_EFF)
|
||||
#include "pins_RAMPS_13.h"
|
||||
#include "pins_RAMPS_13.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RAMPS_13_EEF)
|
||||
#include "pins_RAMPS_13.h"
|
||||
#include "pins_RAMPS_13.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RAMPS_13_SF)
|
||||
#include "pins_RAMPS_13.h"
|
||||
#include "pins_RAMPS_13.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RAMPS_14_EFB)
|
||||
#include "pins_RAMPS.h"
|
||||
#include "pins_RAMPS.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RAMPS_14_EEB)
|
||||
#include "pins_RAMPS.h"
|
||||
#include "pins_RAMPS.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RAMPS_14_EFF)
|
||||
#include "pins_RAMPS.h"
|
||||
#include "pins_RAMPS.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RAMPS_14_EEF)
|
||||
#include "pins_RAMPS.h"
|
||||
#include "pins_RAMPS.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RAMPS_14_SF)
|
||||
#include "pins_RAMPS.h"
|
||||
#include "pins_RAMPS.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RAMPS_PLUS_EFB)
|
||||
#include "pins_RAMPS_PLUS.h"
|
||||
#include "pins_RAMPS_PLUS.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RAMPS_PLUS_EEB)
|
||||
#include "pins_RAMPS_PLUS.h"
|
||||
#include "pins_RAMPS_PLUS.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RAMPS_PLUS_EFF)
|
||||
#include "pins_RAMPS_PLUS.h"
|
||||
#include "pins_RAMPS_PLUS.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RAMPS_PLUS_EEF)
|
||||
#include "pins_RAMPS_PLUS.h"
|
||||
#include "pins_RAMPS_PLUS.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RAMPS_PLUS_SF)
|
||||
#include "pins_RAMPS_PLUS.h"
|
||||
#include "pins_RAMPS_PLUS.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
|
||||
//
|
||||
// RAMPS Derivatives - ATmega1280, ATmega2560
|
||||
//
|
||||
|
||||
#elif MB(3DRAG)
|
||||
#include "pins_3DRAG.h" // ATmega1280, ATmega2560
|
||||
#include "pins_3DRAG.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(K8200)
|
||||
#include "pins_K8200.h" // ATmega1280, ATmega2560 (3DRAG)
|
||||
#include "pins_K8200.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560 (3DRAG)
|
||||
#elif MB(K8400)
|
||||
#include "pins_K8400.h" // ATmega1280, ATmega2560 (3DRAG)
|
||||
#include "pins_K8400.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560 (3DRAG)
|
||||
#elif MB(BAM_DICE)
|
||||
#include "pins_RAMPS.h" // ATmega1280, ATmega2560
|
||||
#include "pins_RAMPS.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(BAM_DICE_DUE)
|
||||
#include "pins_BAM_DICE_DUE.h" // ATmega1280, ATmega2560
|
||||
#include "pins_BAM_DICE_DUE.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(MKS_BASE)
|
||||
#include "pins_MKS_BASE.h" // ATmega1280, ATmega2560
|
||||
#include "pins_MKS_BASE.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(MKS_BASE_15)
|
||||
#include "pins_MKS_BASE_15.h" // ATmega1280, ATmega2560
|
||||
#include "pins_MKS_BASE_15.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(MKS_BASE_HEROIC)
|
||||
#include "pins_MKS_BASE_HEROIC.h" // ATmega1280, ATmega2560
|
||||
#include "pins_MKS_BASE_HEROIC.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(MKS_GEN_13)
|
||||
#include "pins_MKS_GEN_13.h" // ATmega1280, ATmega2560
|
||||
#include "pins_MKS_GEN_13.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(MKS_GEN_L)
|
||||
#include "pins_MKS_GEN_L.h" // ATmega1280, ATmega2560
|
||||
#include "pins_MKS_GEN_L.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(ZRIB_V20)
|
||||
#include "pins_ZRIB_V20.h" // ATmega1280, ATmega2560 (MKS_GEN_13)
|
||||
#include "pins_ZRIB_V20.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560 (MKS_GEN_13)
|
||||
#elif MB(FELIX2)
|
||||
#include "pins_FELIX2.h" // ATmega1280, ATmega2560
|
||||
#include "pins_FELIX2.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RIGIDBOARD)
|
||||
#include "pins_RIGIDBOARD.h" // ATmega1280, ATmega2560
|
||||
#include "pins_RIGIDBOARD.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(RIGIDBOARD_V2)
|
||||
#include "pins_RIGIDBOARD_V2.h" // ATmega1280, ATmega2560
|
||||
#include "pins_RIGIDBOARD_V2.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(SAINSMART_2IN1)
|
||||
#include "pins_SAINSMART_2IN1.h" // ATmega1280, ATmega2560
|
||||
#include "pins_SAINSMART_2IN1.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(ULTIMAKER)
|
||||
#include "pins_ULTIMAKER.h" // ATmega1280, ATmega2560
|
||||
#include "pins_ULTIMAKER.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(ULTIMAKER_OLD)
|
||||
#include "pins_ULTIMAKER_OLD.h" // ATmega1280, ATmega2560
|
||||
#include "pins_ULTIMAKER_OLD.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(AZTEEG_X3)
|
||||
#include "pins_AZTEEG_X3.h" // ATmega2560
|
||||
#include "pins_AZTEEG_X3.h" // ATmega2560 env:megaatmega2560
|
||||
#elif MB(AZTEEG_X3_PRO)
|
||||
#include "pins_AZTEEG_X3_PRO.h" // ATmega2560
|
||||
#include "pins_AZTEEG_X3_PRO.h" // ATmega2560 env:megaatmega2560
|
||||
#elif MB(ULTIMAIN_2)
|
||||
#include "pins_ULTIMAIN_2.h" // ATmega2560
|
||||
#include "pins_ULTIMAIN_2.h" // ATmega2560 env:megaatmega2560
|
||||
#elif MB(RUMBA)
|
||||
#include "pins_RUMBA.h" // ATmega2560
|
||||
#include "pins_RUMBA.h" // ATmega2560 env:megaatmega2560
|
||||
#elif MB(BQ_ZUM_MEGA_3D)
|
||||
#include "pins_BQ_ZUM_MEGA_3D.h" // ATmega2560
|
||||
#include "pins_BQ_ZUM_MEGA_3D.h" // ATmega2560 env:megaatmega2560
|
||||
#elif MB(MAKEBOARD_MINI)
|
||||
#include "pins_MAKEBOARD_MINI.h" // ATmega2560
|
||||
#include "pins_MAKEBOARD_MINI.h" // ATmega2560 env:megaatmega2560
|
||||
#elif MB(TRIGORILLA_13)
|
||||
#include "pins_TRIGORILLA_13.h" // ATmega2560
|
||||
#include "pins_TRIGORILLA_13.h" // ATmega2560 env:megaatmega2560
|
||||
#elif MB(TRIGORILLA_14)
|
||||
#include "pins_TRIGORILLA_14.h" // ATmega2560
|
||||
#include "pins_TRIGORILLA_14.h" // ATmega2560 env:megaatmega2560
|
||||
#elif MB(RAMPS_ENDER_4)
|
||||
#include "pins_RAMPS_ENDER_4.h" // ATmega2560
|
||||
#include "pins_RAMPS_ENDER_4.h" // ATmega2560 env:megaatmega2560
|
||||
|
||||
//
|
||||
// Other ATmega1280, ATmega2560
|
||||
//
|
||||
|
||||
#elif MB(CNCONTROLS_11)
|
||||
#include "pins_CNCONTROLS_11.h" // ATmega1280, ATmega2560
|
||||
#include "pins_CNCONTROLS_11.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(CNCONTROLS_12)
|
||||
#include "pins_CNCONTROLS_12.h" // ATmega1280, ATmega2560
|
||||
#include "pins_CNCONTROLS_12.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(MIGHTYBOARD_REVE)
|
||||
#include "pins_MIGHTYBOARD_REVE.h" // ATmega1280, ATmega2560
|
||||
#include "pins_MIGHTYBOARD_REVE.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(CHEAPTRONIC)
|
||||
#include "pins_CHEAPTRONIC.h" // ATmega2560
|
||||
#include "pins_CHEAPTRONIC.h" // ATmega2560 env:megaatmega2560
|
||||
#elif MB(CHEAPTRONIC_V2)
|
||||
#include "pins_CHEAPTRONICv2.h" // ATmega2560
|
||||
#include "pins_CHEAPTRONICv2.h" // ATmega2560 env:megaatmega2560
|
||||
#elif MB(MEGATRONICS)
|
||||
#include "pins_MEGATRONICS.h" // ATmega2560
|
||||
#include "pins_MEGATRONICS.h" // ATmega2560 env:megaatmega2560
|
||||
#elif MB(MEGATRONICS_2)
|
||||
#include "pins_MEGATRONICS_2.h" // ATmega2560
|
||||
#include "pins_MEGATRONICS_2.h" // ATmega2560 env:megaatmega2560
|
||||
#elif MB(MEGATRONICS_3) || MB(MEGATRONICS_31)
|
||||
#include "pins_MEGATRONICS_3.h" // ATmega2560
|
||||
#include "pins_MEGATRONICS_3.h" // ATmega2560 env:megaatmega2560
|
||||
#elif MB(RAMBO)
|
||||
#include "pins_RAMBO.h" // ATmega2560
|
||||
#include "pins_RAMBO.h" // ATmega2560 env:rambo
|
||||
#elif MB(MINIRAMBO) || MB(MINIRAMBO_10A)
|
||||
#include "pins_MINIRAMBO.h" // ATmega2560
|
||||
#include "pins_MINIRAMBO.h" // ATmega2560 env:rambo
|
||||
#elif MB(EINSY_RAMBO)
|
||||
#include "pins_EINSY_RAMBO.h" // ATmega2560
|
||||
#include "pins_EINSY_RAMBO.h" // ATmega2560 env:rambo
|
||||
#elif MB(EINSY_RETRO)
|
||||
#include "pins_EINSY_RETRO.h" // ATmega2560
|
||||
#include "pins_EINSY_RETRO.h" // ATmega2560 env:rambo
|
||||
#elif MB(ELEFU_3)
|
||||
#include "pins_ELEFU_3.h" // ATmega2560
|
||||
#include "pins_ELEFU_3.h" // ATmega2560 env:megaatmega2560
|
||||
#elif MB(LEAPFROG)
|
||||
#include "pins_LEAPFROG.h" // ATmega1280, ATmega2560
|
||||
#include "pins_LEAPFROG.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(MEGACONTROLLER)
|
||||
#include "pins_MEGACONTROLLER.h" // ATmega2560
|
||||
#include "pins_MEGACONTROLLER.h" // ATmega2560 env:megaatmega2560
|
||||
#elif MB(SCOOVO_X9H)
|
||||
#include "pins_SCOOVO_X9H.h" // ATmega2560
|
||||
#include "pins_SCOOVO_X9H.h" // ATmega2560 env:rambo
|
||||
#elif MB(GT2560_REV_A)
|
||||
#include "pins_GT2560_REV_A.h" // ATmega1280, ATmega2560
|
||||
#include "pins_GT2560_REV_A.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
#elif MB(GT2560_REV_A_PLUS)
|
||||
#include "pins_GT2560_REV_A_PLUS.h" // ATmega1280, ATmega2560
|
||||
#include "pins_GT2560_REV_A_PLUS.h" // ATmega1280, ATmega2560 env:megaatmega1280 env:megaatmega2560
|
||||
|
||||
//
|
||||
// ATmega1281, ATmega2561
|
||||
//
|
||||
|
||||
#elif MB(MINITRONICS)
|
||||
#include "pins_MINITRONICS.h" // ATmega1281
|
||||
#include "pins_MINITRONICS.h" // ATmega1281 env:megaatmega1280
|
||||
#elif MB(SILVER_GATE)
|
||||
#include "pins_SILVER_GATE.h" // ATmega2561
|
||||
#include "pins_SILVER_GATE.h" // ATmega2561 env:megaatmega2560
|
||||
|
||||
//
|
||||
// Sanguinololu and Derivatives - ATmega644P, ATmega1284P
|
||||
//
|
||||
|
||||
#elif MB(SANGUINOLOLU_11)
|
||||
#include "pins_SANGUINOLOLU_11.h" // ATmega644P, ATmega1284P
|
||||
#include "pins_SANGUINOLOLU_11.h" // ATmega644P, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
#elif MB(SANGUINOLOLU_12)
|
||||
#include "pins_SANGUINOLOLU_12.h" // ATmega644P, ATmega1284P
|
||||
#include "pins_SANGUINOLOLU_12.h" // ATmega644P, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
#elif MB(MELZI)
|
||||
#include "pins_MELZI.h" // ATmega644P, ATmega1284P
|
||||
#include "pins_MELZI.h" // ATmega644P, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
#elif MB(MELZI_MAKR3D)
|
||||
#include "pins_MELZI_MAKR3D.h" // ATmega644P, ATmega1284P
|
||||
#include "pins_MELZI_MAKR3D.h" // ATmega644P, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
#elif MB(MELZI_CREALITY)
|
||||
#include "pins_MELZI_CREALITY.h" // ATmega644P, ATmega1284P
|
||||
#include "pins_MELZI_CREALITY.h" // ATmega644P, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
#elif MB(MELZI_MALYAN)
|
||||
#include "pins_MELZI_MALYAN.h" // ATmega644P, ATmega1284P
|
||||
#include "pins_MELZI_MALYAN.h" // ATmega644P, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
#elif MB(MELZI_TRONXY)
|
||||
#include "pins_MELZI_TRONXY.h" // ATmega644P, ATmega1284P
|
||||
#include "pins_MELZI_TRONXY.h" // ATmega644P, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
#elif MB(STB_11)
|
||||
#include "pins_STB_11.h" // ATmega644P, ATmega1284P
|
||||
#include "pins_STB_11.h" // ATmega644P, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
#elif MB(AZTEEG_X1)
|
||||
#include "pins_AZTEEG_X1.h" // ATmega644P, ATmega1284P
|
||||
#include "pins_AZTEEG_X1.h" // ATmega644P, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
|
||||
//
|
||||
// Other ATmega644P, ATmega644, ATmega1284P
|
||||
//
|
||||
|
||||
#elif MB(GEN3_MONOLITHIC)
|
||||
#include "pins_GEN3_MONOLITHIC.h" // ATmega644P
|
||||
#include "pins_GEN3_MONOLITHIC.h" // ATmega644P env:sanguino_atmega644p
|
||||
#elif MB(GEN3_PLUS)
|
||||
#include "pins_GEN3_PLUS.h" // ATmega644P, ATmega1284P
|
||||
#include "pins_GEN3_PLUS.h" // ATmega644P, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
#elif MB(GEN6)
|
||||
#include "pins_GEN6.h" // ATmega644P, ATmega1284P
|
||||
#include "pins_GEN6.h" // ATmega644P, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
#elif MB(GEN6_DELUXE)
|
||||
#include "pins_GEN6_DELUXE.h" // ATmega644P, ATmega1284P
|
||||
#include "pins_GEN6_DELUXE.h" // ATmega644P, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
#elif MB(GEN7_CUSTOM)
|
||||
#include "pins_GEN7_CUSTOM.h" // ATmega644P, ATmega644, ATmega1284P
|
||||
#include "pins_GEN7_CUSTOM.h" // ATmega644P, ATmega644, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
#elif MB(GEN7_12)
|
||||
#include "pins_GEN7_12.h" // ATmega644P, ATmega644, ATmega1284P
|
||||
#include "pins_GEN7_12.h" // ATmega644P, ATmega644, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
#elif MB(GEN7_13)
|
||||
#include "pins_GEN7_13.h" // ATmega644P, ATmega644, ATmega1284P
|
||||
#include "pins_GEN7_13.h" // ATmega644P, ATmega644, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
#elif MB(GEN7_14)
|
||||
#include "pins_GEN7_14.h" // ATmega644P, ATmega644, ATmega1284P
|
||||
#include "pins_GEN7_14.h" // ATmega644P, ATmega644, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
#elif MB(OMCA_A)
|
||||
#include "pins_OMCA_A.h" // ATmega644
|
||||
#include "pins_OMCA_A.h" // ATmega644 env:sanguino_atmega644p
|
||||
#elif MB(OMCA)
|
||||
#include "pins_OMCA.h" // ATmega644P, ATmega644
|
||||
#include "pins_OMCA.h" // ATmega644P, ATmega644 env:sanguino_atmega644p
|
||||
#elif MB(ANET_10)
|
||||
#include "pins_ANET_10.h" // ATmega1284P
|
||||
#include "pins_ANET_10.h" // ATmega1284P env:sanguino_atmega1284p
|
||||
#elif MB(SETHI)
|
||||
#include "pins_SETHI.h" // ATmega644P, ATmega644, ATmega1284P
|
||||
#include "pins_SETHI.h" // ATmega644P, ATmega644, ATmega1284P env:sanguino_atmega644p env:sanguino_atmega1284p
|
||||
|
||||
//
|
||||
// Teensyduino - AT90USB1286, AT90USB1286P
|
||||
//
|
||||
|
||||
#elif MB(TEENSYLU)
|
||||
#include "pins_TEENSYLU.h" // AT90USB1286, AT90USB1286P
|
||||
#include "pins_TEENSYLU.h" // AT90USB1286, AT90USB1286P env:teensy20
|
||||
#elif MB(PRINTRBOARD)
|
||||
#include "pins_PRINTRBOARD.h" // AT90USB1286
|
||||
#include "pins_PRINTRBOARD.h" // AT90USB1286 env:teensy20
|
||||
#elif MB(PRINTRBOARD_REVF)
|
||||
#include "pins_PRINTRBOARD_REVF.h" // AT90USB1286
|
||||
#include "pins_PRINTRBOARD_REVF.h" // AT90USB1286 env:teensy20
|
||||
#elif MB(BRAINWAVE)
|
||||
#include "pins_BRAINWAVE.h" // AT90USB646
|
||||
#include "pins_BRAINWAVE.h" // AT90USB646 env:teensy20
|
||||
#elif MB(BRAINWAVE_PRO)
|
||||
#include "pins_BRAINWAVE_PRO.h" // AT90USB1286
|
||||
#include "pins_BRAINWAVE_PRO.h" // AT90USB1286 env:teensy20
|
||||
#elif MB(SAV_MKI)
|
||||
#include "pins_SAV_MKI.h" // AT90USB1286
|
||||
#include "pins_SAV_MKI.h" // AT90USB1286 env:teensy20
|
||||
#elif MB(TEENSY2)
|
||||
#include "pins_TEENSY2.h" // AT90USB1286
|
||||
#include "pins_TEENSY2.h" // AT90USB1286 env:teensy20
|
||||
#elif MB(5DPRINT)
|
||||
#include "pins_5DPRINT.h" // AT90USB1286
|
||||
#include "pins_5DPRINT.h" // AT90USB1286 env:teensy20
|
||||
|
||||
|
||||
#else
|
||||
#error "Unknown MOTHERBOARD value set in Configuration.h"
|
||||
|
|
|
|||
|
|
@ -0,0 +1,935 @@
|
|||
#######################################
|
||||
#
|
||||
# Marlin 3D Printer Firmware
|
||||
# Copyright (C) 2018 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
||||
#
|
||||
# Based on Sprinter and grbl.
|
||||
# Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
|
||||
#
|
||||
# This program is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation, either version 3 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
#######################################
|
||||
|
||||
#######################################
|
||||
#
|
||||
# Description: script to automate PlatformIO builds
|
||||
# CLI: python auto_build.py build_option
|
||||
# build_option (required)
|
||||
# build executes -> platformio run -e target_env
|
||||
# clean executes -> platformio run --target clean -e target_env
|
||||
# upload executes -> platformio run --target upload -e target_env
|
||||
# traceback executes -> platformio run --target upload -e target_env
|
||||
# program executes -> platformio run --target program -e target_env
|
||||
# test executes -> platformio test upload -e target_env
|
||||
# remote executes -> platformio remote run --target upload -e target_env
|
||||
# debug executes -> platformio debug -e target_env
|
||||
#
|
||||
# 'traceback' just uses the debug variant of the target environment if one exists
|
||||
#
|
||||
#######################################
|
||||
|
||||
#######################################
|
||||
#
|
||||
# General program flow
|
||||
#
|
||||
# 1. Scans Configuration.h for the motherboard name and Marlin version.
|
||||
# 2. Scans pins.h for the motherboard.
|
||||
# returns the CPU(s) and platformio environment(s) used by the motherboard
|
||||
# 3. If further info is needed then a popup gets it from the user.
|
||||
# 4. The OUTPUT_WINDOW class creates a window to display the output of the PlatformIO program.
|
||||
# 5. A thread is created by the OUTPUT_WINDOW class in order to execute the RUN_PIO function.
|
||||
# 6. The RUN_PIO function uses a subprocess to run the CLI version of PlatformIO.
|
||||
# 7. The "iter(pio_subprocess.stdout.readline, '')" function is used to stream the output of
|
||||
# PlatformIO back to the RUN_PIO function.
|
||||
# 8. Each line returned from PlatformIO is formatted to match the color coding seen in the
|
||||
# PlatformIO GUI.
|
||||
# 9. If there is a color change within a line then the line is broken at each color change
|
||||
# and sent separately.
|
||||
# 10. Each formatted segment (could be a full line or a split line) is put into the queue
|
||||
# IO_queue as it arrives from the platformio subprocess.
|
||||
# 11. The OUTPUT_WINDOW class periodically samples IO_queue. If data is available then it
|
||||
# is written to the window.
|
||||
# 12. The window stays open until the user closes it.
|
||||
# 13. The OUTPUT_WINDOW class continues to execute as long as the window is open. This allows
|
||||
# copying, saving, scrolling of the window. A right click popup is available.
|
||||
#
|
||||
#######################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
|
||||
num_args = len(sys.argv)
|
||||
if num_args > 1:
|
||||
build_type = str(sys.argv[1])
|
||||
else:
|
||||
print 'Please specify build type'
|
||||
exit()
|
||||
|
||||
print'build_type: ', build_type
|
||||
|
||||
print '\nWorking\n'
|
||||
|
||||
python_ver = sys.version_info[0] # major version - 2 or 3
|
||||
|
||||
if python_ver == 2:
|
||||
print "python version " + str(sys.version_info[0]) + "." + str(sys.version_info[1]) + "." + str(sys.version_info[2])
|
||||
else:
|
||||
print "python version " + str(sys.version_info[0])
|
||||
print "This script only runs under python 2"
|
||||
exit()
|
||||
|
||||
#########
|
||||
# Python 2 error messages:
|
||||
# Can't find a usable init.tcl in the following directories ...
|
||||
# error "invalid command name "tcl_findLibrary""
|
||||
#
|
||||
# Fix for the above errors on my Win10 system:
|
||||
# search all init.tcl files for the line "package require -exact Tcl" that has the highest 8.5.x number
|
||||
# copy it into the first directory listed in the error messages
|
||||
# set the environmental variables TCLLIBPATH and TCL_LIBRARY to the directory where you found the init.tcl file
|
||||
# reboot
|
||||
#########
|
||||
|
||||
#globals
|
||||
target_env = ''
|
||||
board_name = ''
|
||||
|
||||
|
||||
|
||||
##########################################################################################
|
||||
#
|
||||
# popup to get input from user
|
||||
#
|
||||
##########################################################################################
|
||||
|
||||
def get_answer(board_name, cpu_label_txt, cpu_a_txt, cpu_b_txt):
|
||||
|
||||
|
||||
if python_ver == 2:
|
||||
import Tkinter as tk
|
||||
else:
|
||||
import tkinter as tk
|
||||
|
||||
def CPU_exit_3(): # forward declare functions
|
||||
|
||||
CPU_exit_3_()
|
||||
def CPU_exit_4():
|
||||
|
||||
CPU_exit_4_()
|
||||
def kill_session():
|
||||
kill_session_()
|
||||
|
||||
root_get_answer = tk.Tk()
|
||||
|
||||
root_get_answer.chk_state_1 = 1 # declare variables used by TK and enable
|
||||
|
||||
chk_state_1 = 0 # set initial state of check boxes
|
||||
|
||||
|
||||
global get_answer_val
|
||||
get_answer_val = 2 # return get_answer_val, set default to match chk_state_1 default
|
||||
|
||||
|
||||
l1 = tk.Label(text=board_name,
|
||||
fg = "light green",
|
||||
bg = "dark green",
|
||||
font = "Helvetica 12 bold").grid(row=1)
|
||||
|
||||
l2 = tk.Label(text=cpu_label_txt,
|
||||
fg = "light green",
|
||||
bg = "dark green",
|
||||
font = "Helvetica 16 bold italic").grid(row=2)
|
||||
|
||||
b4 = tk.Checkbutton(text=cpu_a_txt,
|
||||
fg = "black",
|
||||
font = "Times 20 bold ",
|
||||
variable=chk_state_1, onvalue=1, offvalue=0,
|
||||
|
||||
command = CPU_exit_3).grid(row=3)
|
||||
|
||||
b5 = tk.Checkbutton(text=cpu_b_txt,
|
||||
fg = "black",
|
||||
font = "Times 20 bold ",
|
||||
variable=chk_state_1, onvalue=0, offvalue=1,
|
||||
|
||||
command = CPU_exit_4).grid(row=4) # use same variable but inverted so they will track
|
||||
b6 = tk.Button(text="CONFIRM",
|
||||
fg = "blue",
|
||||
font = "Times 20 bold ",
|
||||
command = root_get_answer.destroy).grid(row=5, pady=4)
|
||||
|
||||
b7 = tk.Button(text="CANCEL",
|
||||
fg = "red",
|
||||
font = "Times 12 bold ",
|
||||
command = kill_session).grid(row=6, pady=4)
|
||||
|
||||
|
||||
def CPU_exit_3_():
|
||||
global get_answer_val
|
||||
get_answer_val = 1
|
||||
|
||||
def CPU_exit_4_():
|
||||
global get_answer_val
|
||||
get_answer_val = 2
|
||||
|
||||
def kill_session_():
|
||||
raise SystemExit(0) # kill everything
|
||||
|
||||
root_get_answer.mainloop()
|
||||
|
||||
# end - get answer
|
||||
|
||||
|
||||
|
||||
def env_name_check(argument):
|
||||
name_check = {
|
||||
'teensy35' : True,
|
||||
'teensy20' : True,
|
||||
'STM32F4' : True,
|
||||
'STM32F1' : True,
|
||||
'sanguino_atmega644p' : True,
|
||||
'sanguino_atmega1284p' : True,
|
||||
'rambo' : True,
|
||||
'melzi_optiboot' : True,
|
||||
'melzi' : True,
|
||||
'megaatmega2560' : True,
|
||||
'megaatmega1280' : True,
|
||||
'malyanm200' : True,
|
||||
'LPC1768' : True,
|
||||
'DUE_debug' : True,
|
||||
'DUE_USB' : True,
|
||||
'DUE' : True
|
||||
}
|
||||
|
||||
return name_check.get(argument, False)
|
||||
|
||||
|
||||
# gets the last build environment
|
||||
def get_build_last():
|
||||
env_last = ''
|
||||
DIR_PWD = os.listdir('.')
|
||||
if '.pioenvs' in DIR_PWD:
|
||||
date_last = 0.0
|
||||
DIR__pioenvs = os.listdir('.pioenvs')
|
||||
for name in DIR__pioenvs:
|
||||
if env_name_check(name):
|
||||
DIR_temp = os.listdir('.pioenvs/' + name)
|
||||
for names_temp in DIR_temp:
|
||||
if 0 == names_temp.find('firmware.'):
|
||||
date_temp = os.path.getmtime('.pioenvs/' + name + '/' + names_temp)
|
||||
if date_temp > date_last:
|
||||
date_last = date_temp
|
||||
env_last = name
|
||||
return env_last
|
||||
|
||||
|
||||
# gets the board being built from the Configuration.h file
|
||||
# returns: board name, major version of Marlin being used (1 or 2)
|
||||
def get_board_name():
|
||||
board_name = ''
|
||||
# get board name
|
||||
|
||||
with open('Marlin/Configuration.h', 'r') as myfile:
|
||||
Configuration_h = myfile.read()
|
||||
|
||||
Configuration_h = Configuration_h.split('\n')
|
||||
Marlin_ver = 0 # set version to invalid number
|
||||
for lines in Configuration_h:
|
||||
if 0 == lines.find('#define CONFIGURATION_H_VERSION 01'):
|
||||
Marlin_ver = 1
|
||||
if 0 == lines.find('#define CONFIGURATION_H_VERSION 02'):
|
||||
Marlin_ver = 2
|
||||
board = lines.find(' BOARD_') + 1
|
||||
motherboard = lines.find(' MOTHERBOARD ') + 1
|
||||
define = lines.find('#define ')
|
||||
comment = lines.find('//')
|
||||
if (comment == -1 or comment > board) and \
|
||||
board > motherboard and \
|
||||
motherboard > define and \
|
||||
define >= 0 :
|
||||
spaces = lines.find(' ', board) # find the end of the board substring
|
||||
if spaces == -1:
|
||||
board_name = lines[board : ]
|
||||
else:
|
||||
board_name = lines[board : spaces]
|
||||
break
|
||||
|
||||
|
||||
return board_name, Marlin_ver
|
||||
|
||||
|
||||
# extract first environment name it finds after the start position
|
||||
# returns: environment name and position to start the next search from
|
||||
def get_env_from_line(line, start_position):
|
||||
env = ''
|
||||
next_position = -1
|
||||
env_position = line.find('env:', start_position)
|
||||
if 0 < env_position:
|
||||
next_position = line.find(' ', env_position + 4)
|
||||
if 0 < next_position:
|
||||
env = line[env_position + 4 : next_position]
|
||||
else:
|
||||
env = line[env_position + 4 : ] # at the end of the line
|
||||
return env, next_position
|
||||
|
||||
|
||||
|
||||
#scans pins.h for board name and returns the environment(s) it finds
|
||||
def get_starting_env(board_name_full, version):
|
||||
# get environment starting point
|
||||
|
||||
if version == 1:
|
||||
path = 'Marlin/pins.h'
|
||||
if version == 2:
|
||||
path = 'Marlin/src/pins/pins.h'
|
||||
with open(path, 'r') as myfile:
|
||||
pins_h = myfile.read()
|
||||
|
||||
board_name = board_name_full[ 6 : ] # only use the part after "BOARD_" since we're searching the pins.h file
|
||||
pins_h = pins_h.split('\n')
|
||||
environment = ''
|
||||
board_line = ''
|
||||
cpu_A = ''
|
||||
cpu_B = ''
|
||||
i = 0
|
||||
list_start_found = False
|
||||
for lines in pins_h:
|
||||
i = i + 1 # i is always one ahead of the index into pins_h
|
||||
if 0 < lines.find("Unknown MOTHERBOARD value set in Configuration.h"):
|
||||
break # no more
|
||||
if 0 < lines.find('1280'):
|
||||
list_start_found = True
|
||||
if list_start_found == False: # skip lines until find start of CPU list
|
||||
continue
|
||||
board = lines.find(board_name)
|
||||
comment_start = lines.find('// ')
|
||||
cpu_A_loc = comment_start
|
||||
cpu_B_loc = 0
|
||||
if board > 0: # need to look at the next line for environment info
|
||||
cpu_line = pins_h[i]
|
||||
comment_start = cpu_line.find('// ')
|
||||
env_A, next_position = get_env_from_line(cpu_line, comment_start) # get name of environment & start of search for next
|
||||
env_B, next_position = get_env_from_line(cpu_line, next_position) # get next environment, if it exists
|
||||
env_C, next_position = get_env_from_line(cpu_line, next_position) # get next environment, if it exists
|
||||
break
|
||||
return env_A, env_B, env_C
|
||||
|
||||
|
||||
# scans input string for CPUs that the users may need to select from
|
||||
# returns: CPU name
|
||||
def get_CPU_name(environment):
|
||||
CPU_list = ('1280', '2560','644', '1284', 'LPC1768', 'DUE')
|
||||
CPU_name = ''
|
||||
for CPU in CPU_list:
|
||||
if 0 < environment.find(CPU):
|
||||
return CPU
|
||||
|
||||
|
||||
# get environment to be used for the build
|
||||
# returns: environment
|
||||
def get_env(board_name, ver_Marlin):
|
||||
def no_environment():
|
||||
print 'ERROR - no environment for this board'
|
||||
print board_name
|
||||
raise SystemExit(0) # no environment so quit
|
||||
|
||||
def invalid_board():
|
||||
print 'ERROR - invalid board'
|
||||
print board_name
|
||||
raise SystemExit(0) # quit if unable to find board
|
||||
|
||||
|
||||
CPU_question = ( ('1280', '2560', "1280 or 2560 CPU?"), ('644', '1284', "644 or 1284 CPU?") )
|
||||
|
||||
if 0 < board_name.find('MELZI') :
|
||||
get_answer(board_name, "Which flavor of Melzi?", "Melzi (Optiboot bootloader)", "Melzi ")
|
||||
if 1 == get_answer_val:
|
||||
target_env = 'melzi_optiboot'
|
||||
else:
|
||||
target_env = 'melzi'
|
||||
else:
|
||||
env_A, env_B, env_C = get_starting_env(board_name, ver_Marlin)
|
||||
|
||||
if env_A == '':
|
||||
no_environment()
|
||||
if env_B == '':
|
||||
return env_A # only one environment so finished
|
||||
|
||||
CPU_A = get_CPU_name(env_A)
|
||||
CPU_B = get_CPU_name(env_B)
|
||||
|
||||
for item in CPU_question:
|
||||
if CPU_A == item[0]:
|
||||
get_answer(board_name, item[2], item[0], item[1])
|
||||
if 2 == get_answer_val:
|
||||
target_env = env_B
|
||||
else:
|
||||
target_env = env_A
|
||||
return target_env
|
||||
|
||||
if env_A == 'LPC1768':
|
||||
if build_type == 'traceback' or (build_type == 'clean' and get_build_last() == 'LPC1768_debug_and_upload'):
|
||||
target_env = 'LPC1768_debug_and_upload'
|
||||
else:
|
||||
target_env = 'LPC1768'
|
||||
elif env_A == 'DUE':
|
||||
target_env = 'DUE'
|
||||
if build_type == 'traceback' or (build_type == 'clean' and get_build_last() == 'DUE_debug'):
|
||||
target_env = 'DUE_debug'
|
||||
elif env_B == 'DUE_USB':
|
||||
get_answer(board_name, "DUE: need download port", "USB (native USB) port", "Programming port ")
|
||||
if 1 == get_answer_val:
|
||||
target_env = 'DUE_USB'
|
||||
else:
|
||||
target_env = 'DUE'
|
||||
else:
|
||||
invalid_board()
|
||||
|
||||
if build_type == 'traceback' and not(target_env == 'LPC1768_debug_and_upload' or target_env == 'DUE_debug') and Marlin_ver == 2:
|
||||
print "ERROR - this board isn't setup for traceback"
|
||||
print 'board_name: ', board_name
|
||||
print 'target_env: ', target_env
|
||||
raise SystemExit(0)
|
||||
|
||||
return target_env
|
||||
# end - get_env
|
||||
|
||||
# puts screen text into queue so that the parent thread can fetch the data from this thread
|
||||
import Queue
|
||||
IO_queue = Queue.Queue()
|
||||
def write_to_screen_queue(text, format_tag = 'normal'):
|
||||
double_in = [text, format_tag]
|
||||
IO_queue.put(double_in, block = False)
|
||||
|
||||
|
||||
#
|
||||
# send one line to the terminal screen with syntax highlighting
|
||||
#
|
||||
# input: unformatted text, flags from previous run
|
||||
# returns: formatted text ready to go to the terminal, flags from this run
|
||||
#
|
||||
# This routine remembers the status from call to call because previous
|
||||
# lines can affect how the current line is highlighted
|
||||
#
|
||||
|
||||
# 'static' variables - init here and then keep updating them from within print_line
|
||||
warning = False
|
||||
warning_FROM = False
|
||||
error = False
|
||||
standard = True
|
||||
prev_line_COM = False
|
||||
next_line_warning = False
|
||||
warning_continue = False
|
||||
|
||||
def line_print(line_input):
|
||||
|
||||
global warning
|
||||
global warning_FROM
|
||||
global error
|
||||
global standard
|
||||
global prev_line_COM
|
||||
global next_line_warning
|
||||
global warning_continue
|
||||
|
||||
|
||||
|
||||
|
||||
# all '0' elements must precede all '1' elements or they'll be skipped
|
||||
platformio_highlights = [
|
||||
['Environment', 0, 'highlight_blue'],
|
||||
['[SKIP]', 1, 'warning'],
|
||||
['[ERROR]', 1, 'error'],
|
||||
['[SUCCESS]', 1, 'highlight_green']
|
||||
]
|
||||
|
||||
def write_to_screen_with_replace(text, highlights): # search for highlights & split line accordingly
|
||||
did_something = False
|
||||
for highlight in highlights:
|
||||
found = text.find(highlight[0])
|
||||
if did_something == True:
|
||||
break
|
||||
if found >= 0 :
|
||||
did_something = True
|
||||
if 0 == highlight[1]:
|
||||
found_1 = text.find(' ')
|
||||
found_tab = text.find('\t')
|
||||
if found_1 < 0 or found_1 > found_tab:
|
||||
found_1 = found_tab
|
||||
write_to_screen_queue(text[ : found_1 + 1 ])
|
||||
for highlight_2 in highlights:
|
||||
if highlight[0] == highlight_2[0] :
|
||||
continue
|
||||
found = text.find(highlight_2[0])
|
||||
if found >= 0 :
|
||||
found_space = text.find(' ', found_1 + 1)
|
||||
found_tab = text.find('\t', found_1 + 1)
|
||||
if found_space < 0 or found_space > found_tab:
|
||||
found_space = found_tab
|
||||
found_right = text.find(']', found + 1)
|
||||
write_to_screen_queue(text[found_1 + 1 : found_space + 1 ], highlight[2])
|
||||
write_to_screen_queue(text[found_space + 1 : found + 1 ])
|
||||
write_to_screen_queue(text[found + 1 : found_right], highlight_2[2])
|
||||
write_to_screen_queue(text[found_right : ] + '\n')
|
||||
break
|
||||
break
|
||||
if 1 == highlight[1]:
|
||||
found_right = text.find(']', found + 1)
|
||||
write_to_screen_queue(text[ : found + 1 ])
|
||||
write_to_screen_queue(text[found + 1 : found_right ], highlight[2])
|
||||
write_to_screen_queue(text[found_right : ] + '\n')
|
||||
break
|
||||
if did_something == False:
|
||||
write_to_screen_queue(text + '\n')
|
||||
# end - write_to_screen_with_replace
|
||||
|
||||
|
||||
|
||||
# scan the line
|
||||
max_search = len(line_input)
|
||||
if max_search > 3 :
|
||||
max_search = 3
|
||||
beginning = line_input[:max_search]
|
||||
|
||||
# set flags
|
||||
if 0 < line_input.find(': warning: '): # start of warning block
|
||||
warning = True
|
||||
warning_FROM = False
|
||||
error = False
|
||||
standard = False
|
||||
prev_line_COM = False
|
||||
prev_line_COM = False
|
||||
warning_continue = True
|
||||
if beginning == 'War' or \
|
||||
beginning == '#er' or \
|
||||
beginning == 'In ' or \
|
||||
(beginning != 'Com' and prev_line_COM == True and not(beginning == 'Arc' or beginning == 'Lin' or beginning == 'Ind') or \
|
||||
next_line_warning == True):
|
||||
warning = True #warning found
|
||||
warning_FROM = False
|
||||
error = False
|
||||
standard = False
|
||||
prev_line_COM = False
|
||||
elif beginning == 'Com' or \
|
||||
beginning == 'Ver' or \
|
||||
beginning == ' [E' or \
|
||||
beginning == 'Rem' or \
|
||||
beginning == 'Bui' or \
|
||||
beginning == 'Ind' or \
|
||||
beginning == 'PLA':
|
||||
warning = False #standard line found
|
||||
warning_FROM = False
|
||||
error = False
|
||||
standard = True
|
||||
prev_line_COM = False
|
||||
warning_continue = False
|
||||
elif beginning == '***':
|
||||
warning = False # error found
|
||||
warning_FROM = False
|
||||
error = True
|
||||
standard = False
|
||||
prev_line_COM = False
|
||||
|
||||
elif beginning == 'fro' and warning == True : # start of warning /error block
|
||||
warning_FROM = True
|
||||
prev_line_COM = False
|
||||
warning_continue = True
|
||||
elif 0 < line_input.find(': error:') or \
|
||||
0 < line_input.find(': fatal error:'): # start of warning /error block
|
||||
warning = False # error found
|
||||
warning_FROM = False
|
||||
error = True
|
||||
standard = False
|
||||
prev_line_COM = False
|
||||
warning_continue = True
|
||||
elif warning_continue == True:
|
||||
warning = True
|
||||
warning_FROM = False # keep the warning status going until find a standard line
|
||||
error = False
|
||||
standard = False
|
||||
prev_line_COM = False
|
||||
warning_continue = True
|
||||
|
||||
else:
|
||||
warning = False # unknown so assume standard line
|
||||
warning_FROM = False
|
||||
error = False
|
||||
standard = True
|
||||
prev_line_COM = False
|
||||
warning_continue = False
|
||||
|
||||
if beginning == 'Com':
|
||||
prev_line_COM = True
|
||||
|
||||
# print based on flags
|
||||
if standard == True:
|
||||
write_to_screen_with_replace(line_input, platformio_highlights) #print white on black with substitutions
|
||||
if warning == True:
|
||||
write_to_screen_queue(line_input + '\n', 'warning')
|
||||
if error == True:
|
||||
write_to_screen_queue(line_input + '\n', 'error')
|
||||
# end - line_print
|
||||
|
||||
|
||||
|
||||
def run_PIO(dummy):
|
||||
|
||||
##########################################################################
|
||||
# #
|
||||
# run Platformio #
|
||||
# #
|
||||
##########################################################################
|
||||
|
||||
|
||||
# build platformio run -e target_env
|
||||
# clean platformio run --target clean -e target_env
|
||||
# upload platformio run --target upload -e target_env
|
||||
# traceback platformio run --target upload -e target_env
|
||||
# program platformio run --target program -e target_env
|
||||
# test platformio test upload -e target_env
|
||||
# remote platformio remote run --target upload -e target_env
|
||||
# debug platformio debug -e target_env
|
||||
|
||||
|
||||
global build_type
|
||||
global target_env
|
||||
global board_name
|
||||
print 'build_type: ', build_type
|
||||
|
||||
import subprocess
|
||||
import sys
|
||||
print 'starting platformio'
|
||||
|
||||
if build_type == 'build':
|
||||
# platformio run -e target_env
|
||||
# combine stdout & stderr so all compile messages are included
|
||||
pio_subprocess = subprocess.Popen(['platformio', 'run', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||||
|
||||
|
||||
elif build_type == 'clean':
|
||||
# platformio run --target clean -e target_env
|
||||
# combine stdout & stderr so all compile messages are included
|
||||
pio_subprocess = subprocess.Popen(['platformio', 'run', '--target', 'clean', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||||
|
||||
|
||||
elif build_type == 'upload':
|
||||
# platformio run --target upload -e target_env
|
||||
# combine stdout & stderr so all compile messages are included
|
||||
pio_subprocess = subprocess.Popen(['platformio', 'run', '--target', 'upload', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||||
|
||||
|
||||
elif build_type == 'traceback':
|
||||
# platformio run --target upload -e target_env - select the debug environment if there is one
|
||||
# combine stdout & stderr so all compile messages are included
|
||||
pio_subprocess = subprocess.Popen(['platformio', 'run', '--target', 'upload', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||||
|
||||
|
||||
elif build_type == 'program':
|
||||
# platformio run --target program -e target_env
|
||||
# combine stdout & stderr so all compile messages are included
|
||||
pio_subprocess = subprocess.Popen(['platformio', 'run', '--target', 'program', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||||
|
||||
|
||||
elif build_type == 'test':
|
||||
#platformio test upload -e target_env
|
||||
# combine stdout & stderr so all compile messages are included
|
||||
pio_subprocess = subprocess.Popen(['platformio', 'test', 'upload', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||||
|
||||
|
||||
elif build_type == 'remote':
|
||||
# platformio remote run --target upload -e target_env
|
||||
# combine stdout & stderr so all compile messages are included
|
||||
pio_subprocess = subprocess.Popen(['platformio', 'remote', 'run', '--target', 'program', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||||
|
||||
|
||||
elif build_type == 'debug':
|
||||
# platformio debug -e target_env
|
||||
# combine stdout & stderr so all compile messages are included
|
||||
pio_subprocess = subprocess.Popen(['platformio', 'debug', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||||
|
||||
|
||||
else:
|
||||
print 'ERROR - unknown build type: ', build_type
|
||||
raise SystemExit(0) # kill everything
|
||||
|
||||
# stream output from subprocess and split it into lines
|
||||
for line in iter(pio_subprocess.stdout.readline, ''):
|
||||
line_print(line.replace('\n', ''))
|
||||
|
||||
|
||||
# append info used to run PlatformIO
|
||||
write_to_screen_queue('\nBoard name: ' + board_name + '\n') # put build info at the bottom of the screen
|
||||
write_to_screen_queue('Build type: ' + build_type + '\n')
|
||||
write_to_screen_queue('Environment used: ' + target_env + '\n')
|
||||
# end - run_PIO
|
||||
|
||||
|
||||
########################################################################
|
||||
|
||||
import time
|
||||
import threading
|
||||
import Tkinter as tk
|
||||
import ttk
|
||||
import Queue
|
||||
import subprocess
|
||||
import sys
|
||||
que = Queue.Queue()
|
||||
#IO_queue = Queue.Queue()
|
||||
|
||||
from Tkinter import Tk, Frame, Text, Scrollbar, Menu
|
||||
from tkMessageBox import askokcancel
|
||||
|
||||
import tkFileDialog
|
||||
from tkMessageBox import askokcancel
|
||||
import tkFileDialog
|
||||
|
||||
|
||||
|
||||
class output_window(Text):
|
||||
|
||||
global continue_updates
|
||||
continue_updates = True
|
||||
|
||||
|
||||
def __init__(self):
|
||||
|
||||
|
||||
self.root = tk.Tk()
|
||||
self.frame = tk.Frame(self.root)
|
||||
self.frame.pack(fill='both', expand=True)
|
||||
|
||||
# text widget
|
||||
#self.text = tk.Text(self.frame, borderwidth=3, relief="sunken")
|
||||
Text.__init__(self, self.frame, borderwidth=3, relief="sunken")
|
||||
self.config(tabs=(400,)) # configure Text widget tab stops
|
||||
self.config(background = 'black', foreground = 'white', font= ("consolas", 12), wrap = 'word', undo = 'True')
|
||||
self.config(height = 24, width = 120)
|
||||
self.pack(side='left', fill='both', expand=True)
|
||||
|
||||
self.tag_config('normal', foreground = 'white')
|
||||
self.tag_config('warning', foreground = 'yellow' )
|
||||
self.tag_config('error', foreground = 'red')
|
||||
self.tag_config('highlight_green', foreground = 'green')
|
||||
self.tag_config('highlight_blue', foreground = 'cyan')
|
||||
|
||||
# self.bind('<Control-Key-a>', self.select_all) # the event happens but the action doesn't
|
||||
|
||||
# scrollbar
|
||||
|
||||
scrb = tk.Scrollbar(self.frame, orient='vertical', command=self.yview)
|
||||
self.config(yscrollcommand=scrb.set)
|
||||
scrb.pack(side='right', fill='y')
|
||||
|
||||
|
||||
# pop-up menu
|
||||
self.popup = tk.Menu(self, tearoff=0)
|
||||
self.popup.add_command(label='Cut', command=self._cut)
|
||||
self.popup.add_command(label='Copy', command=self._copy)
|
||||
self.popup.add_command(label='Paste', command=self._paste)
|
||||
self.popup.add_separator()
|
||||
self.popup.add_command(label='Select All', command=self._select_all)
|
||||
self.popup.add_command(label='Clear All', command=self._clear_all)
|
||||
self.popup.add_separator()
|
||||
self.popup.add_command(label='Save As', command=self._file_save_as)
|
||||
self.bind('<Button-3>', self._show_popup)
|
||||
|
||||
|
||||
# threading & subprocess section
|
||||
|
||||
def start_thread(self, ):
|
||||
global continue_updates
|
||||
# create then start a secondary thread to run an arbitrary function
|
||||
# must have at least one argument
|
||||
self.secondary_thread = threading.Thread(target = lambda q, arg1: q.put(run_PIO(arg1)), args=(que, ''))
|
||||
self.secondary_thread.start()
|
||||
continue_updates = True
|
||||
# check the Queue in 50ms
|
||||
self.root.after(50, self.check_thread)
|
||||
self.root.after(50, self.update)
|
||||
|
||||
|
||||
def check_thread(self): # wait for user to kill the window
|
||||
global continue_updates
|
||||
if continue_updates == True:
|
||||
self.root.after(20, self.check_thread)
|
||||
|
||||
|
||||
def update(self):
|
||||
global continue_updates
|
||||
if continue_updates == True:
|
||||
self.root.after(20, self.update)#method is called every 50ms
|
||||
temp_text = ['0','0']
|
||||
if IO_queue.empty():
|
||||
if not(self.secondary_thread.is_alive()):
|
||||
continue_updates = False # queue is exhausted and thread is dead so no need for further updates
|
||||
self.tag_add('sel', '1.0', 'end')
|
||||
else:
|
||||
try:
|
||||
temp_text = IO_queue.get(block = False)
|
||||
except Queue.Empty:
|
||||
continue_updates = False # queue is exhausted so no need for further updates
|
||||
else:
|
||||
self.insert('end', temp_text[0], temp_text[1])
|
||||
self.see("end") # make the last line visible (scroll text off the top)
|
||||
|
||||
|
||||
# text editing section
|
||||
|
||||
def _file_save_as(self):
|
||||
self.filename = tkFileDialog.asksaveasfilename(defaultextension = '.txt')
|
||||
f = open(self.filename, 'w')
|
||||
f.write(self.get('1.0', 'end'))
|
||||
f.close()
|
||||
|
||||
|
||||
|
||||
def copy(self, event):
|
||||
try:
|
||||
selection = self.get(*self.tag_ranges('sel'))
|
||||
self.clipboard_clear()
|
||||
self.clipboard_append(selection)
|
||||
except TypeError:
|
||||
pass
|
||||
|
||||
def cut(self, event):
|
||||
|
||||
try:
|
||||
selection = self.get(*self.tag_ranges('sel'))
|
||||
self.clipboard_clear()
|
||||
self.clipboard_append(selection)
|
||||
self.delete(*self.tag_ranges('sel'))
|
||||
except TypeError:
|
||||
pass
|
||||
|
||||
def _show_popup(self, event):
|
||||
'''right-click popup menu'''
|
||||
|
||||
if self.root.focus_get() != self:
|
||||
self.root.focus_set()
|
||||
|
||||
try:
|
||||
self.popup.tk_popup(event.x_root, event.y_root, 0)
|
||||
finally:
|
||||
self.popup.grab_release()
|
||||
|
||||
def _cut(self):
|
||||
|
||||
try:
|
||||
selection = self.get(*self.tag_ranges('sel'))
|
||||
self.clipboard_clear()
|
||||
self.clipboard_append(selection)
|
||||
self.delete(*self.tag_ranges('sel'))
|
||||
except TypeError:
|
||||
pass
|
||||
|
||||
def cut(self, event):
|
||||
_cut(self)
|
||||
|
||||
def _copy(self):
|
||||
|
||||
try:
|
||||
selection = self.get(*self.tag_ranges('sel'))
|
||||
self.clipboard_clear()
|
||||
self.clipboard_append(selection)
|
||||
except TypeError:
|
||||
pass
|
||||
|
||||
def copy(self, event):
|
||||
_copy(self)
|
||||
|
||||
def _paste(self):
|
||||
|
||||
self.insert('insert', self.selection_get(selection='CLIPBOARD'))
|
||||
|
||||
def _select_all(self):
|
||||
self.tag_add('sel', '1.0', 'end')
|
||||
|
||||
|
||||
def select_all(self, event):
|
||||
self.tag_add('sel', '1.0', 'end')
|
||||
|
||||
|
||||
def _clear_all(self):
|
||||
'''erases all text'''
|
||||
|
||||
isok = askokcancel('Clear All', 'Erase all text?', frame=self,
|
||||
default='ok')
|
||||
if isok:
|
||||
self.delete('1.0', 'end')
|
||||
|
||||
def _place_cursor(self): # theme: terminal
|
||||
'''check the position of the cursor against the last known position
|
||||
every 15ms and update the cursorblock tag as needed'''
|
||||
|
||||
current_index = self.index('insert')
|
||||
|
||||
if self.cursor != current_index:
|
||||
self.cursor = current_index
|
||||
self.tag_delete('cursorblock')
|
||||
|
||||
start = self.index('insert')
|
||||
end = self.index('insert+1c')
|
||||
|
||||
if start[0] != end[0]:
|
||||
self.insert(start, ' ')
|
||||
end = self.index('insert')
|
||||
|
||||
self.tag_add('cursorblock', start, end)
|
||||
self.mark_set('insert', self.cursor)
|
||||
|
||||
self.after(15, self._place_cursor)
|
||||
|
||||
def _blink_cursor(self): # theme: terminal
|
||||
'''alternate the background color of the cursorblock tagged text
|
||||
every 600 milliseconds'''
|
||||
|
||||
if self.switch == self.fg:
|
||||
self.switch = self.bg
|
||||
else:
|
||||
self.switch = self.fg
|
||||
|
||||
self.tag_config('cursorblock', background=self.switch)
|
||||
|
||||
self.after(600, self._blink_cursor)
|
||||
# end - output_window
|
||||
|
||||
|
||||
|
||||
def main():
|
||||
|
||||
|
||||
##########################################################################
|
||||
# #
|
||||
# main program #
|
||||
# #
|
||||
##########################################################################
|
||||
|
||||
global build_type
|
||||
global target_env
|
||||
global board_name
|
||||
|
||||
board_name, Marlin_ver = get_board_name()
|
||||
|
||||
target_env = get_env(board_name, Marlin_ver)
|
||||
|
||||
auto_build = output_window()
|
||||
auto_build.start_thread() # executes the "run_PIO" function
|
||||
|
||||
auto_build.root.mainloop()
|
||||
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
main()
|
||||
|
|
@ -52,15 +52,6 @@ build_flags = ${common.build_flags}
|
|||
board_f_cpu = 16000000L
|
||||
lib_deps = ${common.lib_deps}
|
||||
|
||||
#
|
||||
# Brainwave Pro (Teensy 2.0)
|
||||
#
|
||||
[env:brainwavepro]
|
||||
platform = teensy
|
||||
framework = arduino
|
||||
board = teensy20pp
|
||||
build_flags = ${common.build_flags} -D MOTHERBOARD=BOARD_BRAINWAVE_PRO
|
||||
lib_deps = ${common.lib_deps}
|
||||
|
||||
#
|
||||
# Melzi and clones (ATmega1284p)
|
||||
|
|
@ -85,28 +76,6 @@ build_flags = ${common.build_flags}
|
|||
upload_speed = 115200
|
||||
lib_deps = ${common.lib_deps}
|
||||
|
||||
#
|
||||
# Printrboard (Teensy 2.0)
|
||||
#
|
||||
[env:printrboard]
|
||||
platform = teensy
|
||||
framework = arduino
|
||||
board = teensy20pp
|
||||
build_flags = ${common.build_flags} -D MOTHERBOARD=BOARD_PRINTRBOARD
|
||||
# Bug in arduino framework does not allow boards running at 20Mhz
|
||||
#board_f_cpu = 20000000L
|
||||
lib_deps = ${common.lib_deps}
|
||||
|
||||
#
|
||||
# Printrboard Rev.F (Teensy 2.0)
|
||||
#
|
||||
[env:printrboard_revf]
|
||||
platform = teensy
|
||||
framework = arduino
|
||||
board = teensy20pp
|
||||
build_flags = ${common.build_flags} -D MOTHERBOARD=BOARD_PRINTRBOARD_REVF
|
||||
lib_deps = ${common.lib_deps}
|
||||
|
||||
#
|
||||
# RAMBo
|
||||
#
|
||||
|
|
@ -138,3 +107,17 @@ board = sanguino_atmega1284p
|
|||
build_flags = ${common.build_flags}
|
||||
lib_deps = ${common.lib_deps}
|
||||
|
||||
|
||||
#
|
||||
# Teensy++ 2.0
|
||||
#
|
||||
# - PrintrBoard
|
||||
# - PrintrBoard Rev.F
|
||||
# - Brainwave Pro
|
||||
#
|
||||
[env:teensy20]
|
||||
platform = teensy
|
||||
framework = arduino
|
||||
board = teensy20pp
|
||||
build_flags = ${common.build_flags}
|
||||
lib_deps = ${common.lib_deps}
|
||||
|
|
@ -0,0 +1,357 @@
|
|||
{
|
||||
"patterns": {
|
||||
"P1": {
|
||||
"expression": "(path):(line)"
|
||||
},
|
||||
"P2": {
|
||||
"expression": "(path)\\s+(line)",
|
||||
"path": "(?:\\/[\\w\\.\\-]+)+"
|
||||
}
|
||||
},
|
||||
"commands": [
|
||||
{
|
||||
"namespace": "process-palette",
|
||||
"action": "PIO Build",
|
||||
"command": "python buildroot/share/atom/auto_build.py build",
|
||||
"arguments": [],
|
||||
"cwd": "{projectPath}",
|
||||
"inputDialogs": [],
|
||||
"env": {},
|
||||
"keystroke": null,
|
||||
"stream": true,
|
||||
"outputTarget": "panel",
|
||||
"outputBufferSize": 80000,
|
||||
"maxCompleted": 3,
|
||||
"autoShowOutput": true,
|
||||
"autoHideOutput": false,
|
||||
"scrollLockEnabled": false,
|
||||
"singular": true,
|
||||
"promptToSave": true,
|
||||
"saveOption": "none",
|
||||
"patterns": [
|
||||
"default"
|
||||
],
|
||||
"successOutput": "{stdout}",
|
||||
"errorOutput": "{stdout}\n{stderr}",
|
||||
"fatalOutput": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"startMessage": "",
|
||||
"successMessage": "Executed : {fullCommand}",
|
||||
"errorMessage": "Executed : {fullCommand}\nReturned with code {exitStatus}\n{stderr}",
|
||||
"fatalMessage": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"menus": [
|
||||
"Auto Build"
|
||||
],
|
||||
"startScript": null,
|
||||
"successScript": null,
|
||||
"errorScript": null,
|
||||
"scriptOnStart": false,
|
||||
"scriptOnSuccess": false,
|
||||
"scriptOnError": false,
|
||||
"notifyOnStart": false,
|
||||
"notifyOnSuccess": true,
|
||||
"notifyOnError": true,
|
||||
"input": null
|
||||
},
|
||||
{
|
||||
"namespace": "process-palette",
|
||||
"action": "PIO Clean",
|
||||
"command": "python buildroot/share/atom/auto_build.py clean",
|
||||
"arguments": [],
|
||||
"cwd": "{projectPath}",
|
||||
"inputDialogs": [],
|
||||
"env": {},
|
||||
"keystroke": null,
|
||||
"stream": true,
|
||||
"outputTarget": "panel",
|
||||
"outputBufferSize": 80000,
|
||||
"maxCompleted": 3,
|
||||
"autoShowOutput": true,
|
||||
"autoHideOutput": false,
|
||||
"scrollLockEnabled": false,
|
||||
"singular": false,
|
||||
"promptToSave": true,
|
||||
"saveOption": "none",
|
||||
"patterns": [
|
||||
"default"
|
||||
],
|
||||
"successOutput": "{stdout}",
|
||||
"errorOutput": "{stdout}\n{stderr}",
|
||||
"fatalOutput": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"startMessage": null,
|
||||
"successMessage": "Executed : {fullCommand}",
|
||||
"errorMessage": "Executed : {fullCommand}\nReturned with code {exitStatus}\n{stderr}",
|
||||
"fatalMessage": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"menus": [
|
||||
"Auto Build"
|
||||
],
|
||||
"startScript": null,
|
||||
"successScript": null,
|
||||
"errorScript": null,
|
||||
"scriptOnStart": false,
|
||||
"scriptOnSuccess": false,
|
||||
"scriptOnError": false,
|
||||
"notifyOnStart": false,
|
||||
"notifyOnSuccess": true,
|
||||
"notifyOnError": true,
|
||||
"input": null
|
||||
},
|
||||
{
|
||||
"namespace": "process-palette",
|
||||
"action": "PIO Upload",
|
||||
"command": "python buildroot/share/atom/auto_build.py upload",
|
||||
"arguments": [],
|
||||
"cwd": "{projectPath}",
|
||||
"inputDialogs": [],
|
||||
"env": {},
|
||||
"keystroke": null,
|
||||
"stream": true,
|
||||
"outputTarget": "panel",
|
||||
"outputBufferSize": 80000,
|
||||
"maxCompleted": 3,
|
||||
"autoShowOutput": true,
|
||||
"autoHideOutput": false,
|
||||
"scrollLockEnabled": false,
|
||||
"singular": false,
|
||||
"promptToSave": true,
|
||||
"saveOption": "none",
|
||||
"patterns": [
|
||||
"default"
|
||||
],
|
||||
"successOutput": "{stdout}",
|
||||
"errorOutput": "{stdout}\n{stderr}",
|
||||
"fatalOutput": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"startMessage": null,
|
||||
"successMessage": "Executed : {fullCommand}",
|
||||
"errorMessage": "Executed : {fullCommand}\nReturned with code {exitStatus}\n{stderr}",
|
||||
"fatalMessage": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"menus": [
|
||||
"Auto Build"
|
||||
],
|
||||
"startScript": null,
|
||||
"successScript": null,
|
||||
"errorScript": null,
|
||||
"scriptOnStart": false,
|
||||
"scriptOnSuccess": false,
|
||||
"scriptOnError": false,
|
||||
"notifyOnStart": false,
|
||||
"notifyOnSuccess": true,
|
||||
"notifyOnError": true,
|
||||
"input": null
|
||||
},
|
||||
{
|
||||
"namespace": "process-palette",
|
||||
"action": "PIO Upload (traceback)",
|
||||
"command": "python buildroot/share/atom/auto_build.py traceback",
|
||||
"arguments": [],
|
||||
"cwd": "{projectPath}",
|
||||
"inputDialogs": [],
|
||||
"env": {},
|
||||
"keystroke": null,
|
||||
"stream": true,
|
||||
"outputTarget": "panel",
|
||||
"outputBufferSize": 80000,
|
||||
"maxCompleted": 3,
|
||||
"autoShowOutput": true,
|
||||
"autoHideOutput": false,
|
||||
"scrollLockEnabled": false,
|
||||
"singular": false,
|
||||
"promptToSave": true,
|
||||
"saveOption": "none",
|
||||
"patterns": [
|
||||
"default"
|
||||
],
|
||||
"successOutput": "{stdout}",
|
||||
"errorOutput": "{stdout}\n{stderr}",
|
||||
"fatalOutput": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"startMessage": null,
|
||||
"successMessage": "Executed : {fullCommand}",
|
||||
"errorMessage": "Executed : {fullCommand}\nReturned with code {exitStatus}\n{stderr}",
|
||||
"fatalMessage": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"menus": [
|
||||
"Auto Build"
|
||||
],
|
||||
"startScript": null,
|
||||
"successScript": null,
|
||||
"errorScript": null,
|
||||
"scriptOnStart": false,
|
||||
"scriptOnSuccess": false,
|
||||
"scriptOnError": false,
|
||||
"notifyOnStart": false,
|
||||
"notifyOnSuccess": true,
|
||||
"notifyOnError": true,
|
||||
"input": null
|
||||
},
|
||||
{
|
||||
"namespace": "process-palette",
|
||||
"action": "PIO Upload using Programmer",
|
||||
"command": "python buildroot/share/atom/auto_build.py program",
|
||||
"arguments": [],
|
||||
"cwd": "{projectPath}",
|
||||
"inputDialogs": [],
|
||||
"env": {},
|
||||
"keystroke": null,
|
||||
"stream": true,
|
||||
"outputTarget": "panel",
|
||||
"outputBufferSize": 80000,
|
||||
"maxCompleted": 3,
|
||||
"autoShowOutput": true,
|
||||
"autoHideOutput": false,
|
||||
"scrollLockEnabled": false,
|
||||
"singular": false,
|
||||
"promptToSave": true,
|
||||
"saveOption": "none",
|
||||
"patterns": [
|
||||
"default"
|
||||
],
|
||||
"successOutput": "{stdout}",
|
||||
"errorOutput": "{stdout}\n{stderr}",
|
||||
"fatalOutput": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"startMessage": null,
|
||||
"successMessage": "Executed : {fullCommand}",
|
||||
"errorMessage": "Executed : {fullCommand}\nReturned with code {exitStatus}\n{stderr}",
|
||||
"fatalMessage": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"menus": [
|
||||
"Auto Build"
|
||||
],
|
||||
"startScript": null,
|
||||
"successScript": null,
|
||||
"errorScript": null,
|
||||
"scriptOnStart": false,
|
||||
"scriptOnSuccess": false,
|
||||
"scriptOnError": false,
|
||||
"notifyOnStart": false,
|
||||
"notifyOnSuccess": true,
|
||||
"notifyOnError": true,
|
||||
"input": null
|
||||
},
|
||||
{
|
||||
"namespace": "process-palette",
|
||||
"action": "PIO Test",
|
||||
"command": "python buildroot/share/atom/auto_build.py test",
|
||||
"arguments": [],
|
||||
"cwd": "{projectPath}",
|
||||
"inputDialogs": [],
|
||||
"env": {},
|
||||
"keystroke": null,
|
||||
"stream": true,
|
||||
"outputTarget": "panel",
|
||||
"outputBufferSize": 80000,
|
||||
"maxCompleted": 3,
|
||||
"autoShowOutput": true,
|
||||
"autoHideOutput": false,
|
||||
"scrollLockEnabled": false,
|
||||
"singular": false,
|
||||
"promptToSave": true,
|
||||
"saveOption": "none",
|
||||
"patterns": [
|
||||
"default"
|
||||
],
|
||||
"successOutput": "{stdout}",
|
||||
"errorOutput": "{stdout}\n{stderr}",
|
||||
"fatalOutput": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"startMessage": null,
|
||||
"successMessage": "Executed : {fullCommand}",
|
||||
"errorMessage": "Executed : {fullCommand}\nReturned with code {exitStatus}\n{stderr}",
|
||||
"fatalMessage": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"menus": [
|
||||
"Auto Build"
|
||||
],
|
||||
"startScript": null,
|
||||
"successScript": null,
|
||||
"errorScript": null,
|
||||
"scriptOnStart": false,
|
||||
"scriptOnSuccess": false,
|
||||
"scriptOnError": false,
|
||||
"notifyOnStart": false,
|
||||
"notifyOnSuccess": true,
|
||||
"notifyOnError": true,
|
||||
"input": null
|
||||
},
|
||||
{
|
||||
"namespace": "process-palette",
|
||||
"action": "PIO Debug",
|
||||
"command": "python buildroot/share/atom/auto_build.py debug",
|
||||
"arguments": [],
|
||||
"cwd": "{projectPath}",
|
||||
"inputDialogs": [],
|
||||
"env": {},
|
||||
"keystroke": null,
|
||||
"stream": true,
|
||||
"outputTarget": "panel",
|
||||
"outputBufferSize": 80000,
|
||||
"maxCompleted": 3,
|
||||
"autoShowOutput": true,
|
||||
"autoHideOutput": false,
|
||||
"scrollLockEnabled": false,
|
||||
"singular": false,
|
||||
"promptToSave": true,
|
||||
"saveOption": "none",
|
||||
"patterns": [
|
||||
"default"
|
||||
],
|
||||
"successOutput": "{stdout}",
|
||||
"errorOutput": "{stdout}\n{stderr}",
|
||||
"fatalOutput": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"startMessage": null,
|
||||
"successMessage": "Executed : {fullCommand}",
|
||||
"errorMessage": "Executed : {fullCommand}\nReturned with code {exitStatus}\n{stderr}",
|
||||
"fatalMessage": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"menus": [
|
||||
"Auto Build"
|
||||
],
|
||||
"startScript": null,
|
||||
"successScript": null,
|
||||
"errorScript": null,
|
||||
"scriptOnStart": false,
|
||||
"scriptOnSuccess": false,
|
||||
"scriptOnError": false,
|
||||
"notifyOnStart": false,
|
||||
"notifyOnSuccess": true,
|
||||
"notifyOnError": true,
|
||||
"input": null
|
||||
},
|
||||
{
|
||||
"namespace": "process-palette",
|
||||
"action": "PIO Remote",
|
||||
"command": "python buildroot/share/atom/auto_build.py remote",
|
||||
"arguments": [],
|
||||
"cwd": "{projectPath}",
|
||||
"inputDialogs": [],
|
||||
"env": {},
|
||||
"keystroke": null,
|
||||
"stream": true,
|
||||
"outputTarget": "panel",
|
||||
"outputBufferSize": 80000,
|
||||
"maxCompleted": 3,
|
||||
"autoShowOutput": true,
|
||||
"autoHideOutput": false,
|
||||
"scrollLockEnabled": false,
|
||||
"singular": false,
|
||||
"promptToSave": true,
|
||||
"saveOption": "none",
|
||||
"patterns": [
|
||||
"default"
|
||||
],
|
||||
"successOutput": "{stdout}",
|
||||
"errorOutput": "{stdout}\n{stderr}",
|
||||
"fatalOutput": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"startMessage": null,
|
||||
"successMessage": "Executed : {fullCommand}",
|
||||
"errorMessage": "Executed : {fullCommand}\nReturned with code {exitStatus}\n{stderr}",
|
||||
"fatalMessage": "Failed to execute : {fullCommand}\n{stdout}\n{stderr}",
|
||||
"menus": [
|
||||
"Auto Build"
|
||||
],
|
||||
"startScript": null,
|
||||
"successScript": null,
|
||||
"errorScript": null,
|
||||
"scriptOnStart": false,
|
||||
"scriptOnSuccess": false,
|
||||
"scriptOnError": false,
|
||||
"notifyOnStart": false,
|
||||
"notifyOnSuccess": true,
|
||||
"notifyOnError": true,
|
||||
"input": null
|
||||
}
|
||||
]
|
||||
}
|
||||
Loading…
Reference in New Issue