1456 lines
54 KiB
Python
1456 lines
54 KiB
Python
#######################################
|
|
#
|
|
# 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/>.
|
|
#
|
|
#######################################
|
|
|
|
#######################################
|
|
#
|
|
# Revision: 2.0.1
|
|
#
|
|
# 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
|
|
|
|
pwd = os.getcwd() # make sure we're executing from the correct directory level
|
|
pwd = pwd.replace('\\', '/')
|
|
if 0 <= pwd.find('buildroot/share/atom'):
|
|
pwd = pwd[ : pwd.find('buildroot/share/atom')]
|
|
os.chdir(pwd)
|
|
print 'pwd: ', pwd
|
|
|
|
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()
|
|
|
|
import platform
|
|
current_OS = platform.system()
|
|
|
|
#globals
|
|
target_env = ''
|
|
board_name = ''
|
|
|
|
|
|
#########
|
|
# 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
|
|
#########
|
|
|
|
#
|
|
# data/definitions used by memory check routine to determine if need to
|
|
# insert % memory used
|
|
#
|
|
mem_check_environments = ('at90USB1286_CDC', 'at90USB1286_DFU')
|
|
mem_check_builds = ('upload', 'program')
|
|
FLASH_MAX = 128 * 1024 - 4 * 1024 # DFU & CDC bootloaders start at word address F800
|
|
RAM_MAX = 8 * 1024
|
|
FLASH_PERCENT_WARN = 0.90
|
|
RAM_SYSTEM = 1024 # assume that 1K bytes is enough for stack, heap. ...
|
|
RAM_WARN = RAM_SYSTEM * 1.5
|
|
|
|
##########################################################################################
|
|
#
|
|
# 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
|
|
|
|
|
|
#
|
|
# move custom board definitions from project folder to PlatformIO
|
|
#
|
|
def resolve_path(path):
|
|
import os
|
|
|
|
# turn the selection into a partial path
|
|
|
|
if 0 <= path.find('"'):
|
|
path = path[ path.find('"') : ]
|
|
if 0 <= path.find(', line '):
|
|
path = path.replace(', line ', ':')
|
|
path = path.replace('"', '')
|
|
|
|
#get line and column numbers
|
|
line_num = 1
|
|
column_num = 1
|
|
line_start = path.find(':', 2) # use 2 here so don't eat Windows full path
|
|
column_start = path.find(':', line_start + 1)
|
|
if column_start == -1:
|
|
column_start = len(path)
|
|
column_end = path.find(':', column_start + 1)
|
|
if column_end == -1:
|
|
column_end = len(path)
|
|
if 0 <= line_start:
|
|
line_num = path[ line_start + 1 : column_start]
|
|
if line_num == '':
|
|
line_num = 1
|
|
if not(column_start == column_end):
|
|
column_num = path[ column_start + 1 : column_end]
|
|
if column_num == '':
|
|
column_num = 0
|
|
|
|
index_end = path.find(',')
|
|
if 0 <= index_end:
|
|
path = path[ : index_end] # delete comma and anything after
|
|
index_end = path.find(':', 2)
|
|
if 0 <= index_end:
|
|
path = path[ : path.find(':', 2)] # delete the line number and anything after
|
|
|
|
path = path.replace('\\','/')
|
|
|
|
if 1 == path.find(':') and current_OS == 'Windows':
|
|
return path, line_num, column_num # found a full path - no need for further processing
|
|
elif 0 == path.find('/') and (current_OS == 'Linux' or current_OS == 'Darwin'):
|
|
return path, line_num, column_num # found a full path - no need for further processing
|
|
|
|
else:
|
|
|
|
# resolve as many '../' as we can
|
|
while 0 <= path.find('../'):
|
|
end = path.find('../') - 1
|
|
start = path.find('/')
|
|
while 0 <= path.find('/',start) and end > path.find('/',start):
|
|
start = path.find('/',start) + 1
|
|
path = path[0:start] + path[end + 4: ]
|
|
|
|
# this is an alternative to the above - it just deletes the '../' section
|
|
# start_temp = path.find('../')
|
|
# while 0 <= path.find('../',start_temp):
|
|
# start = path.find('../',start_temp)
|
|
# start_temp = start + 1
|
|
# if 0 <= start:
|
|
# path = path[start + 2 : ]
|
|
|
|
|
|
start = path.find('/')
|
|
if not(0 == start): # make sure path starts with '/'
|
|
while 0 == path.find(' '): # eat any spaces at the beginning
|
|
path = path[ 1 : ]
|
|
path = '/' + path
|
|
|
|
if current_OS == 'Windows':
|
|
search_path = path.replace('/', '\\') # os.walk uses '\' in Windows
|
|
else:
|
|
search_path = path
|
|
|
|
start_path = os.path.abspath('')
|
|
|
|
# search project directory for the selection
|
|
found = False
|
|
full_path = ''
|
|
for root, directories, filenames in os.walk(start_path):
|
|
for filename in filenames:
|
|
if 0 <= root.find('.git'): # don't bother looking in this directory
|
|
break
|
|
full_path = os.path.join(root,filename)
|
|
if 0 <= full_path.find(search_path):
|
|
found = True
|
|
break
|
|
if found:
|
|
break
|
|
|
|
return full_path, line_num, column_num
|
|
|
|
# end - resolve_path
|
|
|
|
|
|
#
|
|
# Opens the file in the preferred editor at the line & column number
|
|
# If the preferred editor isn't already running then it tries the next.
|
|
# If none are open then the system default is used.
|
|
#
|
|
# Editor order:
|
|
# 1. Notepad++ (Windows only)
|
|
# 2. Sublime Text
|
|
# 3. Atom
|
|
# 4. System default (opens at line 1, column 1 only)
|
|
#
|
|
def open_file(path):
|
|
import subprocess
|
|
file_path, line_num, column_num = resolve_path(path)
|
|
|
|
if file_path == '' :
|
|
return
|
|
|
|
if current_OS == 'Windows':
|
|
|
|
editor_note = subprocess.check_output('wmic process where "name=' + "'notepad++.exe'" + '" get ExecutablePath')
|
|
editor_sublime = subprocess.check_output('wmic process where "name=' + "'sublime_text.exe'" + '" get ExecutablePath')
|
|
editor_atom = subprocess.check_output('wmic process where "name=' + "'atom.exe'" + '" get ExecutablePath')
|
|
|
|
if 0 <= editor_note.find('notepad++.exe'):
|
|
start = editor_note.find('\n') + 1
|
|
end = editor_note.find('\n',start + 5) -4
|
|
editor_note = editor_note[ start : end]
|
|
command = file_path , ' -n' + str(line_num) , ' -c' + str(column_num)
|
|
subprocess.Popen([editor_note, command])
|
|
|
|
elif 0 <= editor_sublime.find('sublime_text.exe'):
|
|
start = editor_sublime.find('\n') + 1
|
|
end = editor_sublime.find('\n',start + 5) -4
|
|
editor_sublime = editor_sublime[ start : end]
|
|
command = file_path + ':' + line_num + ':' + column_num
|
|
subprocess.Popen([editor_sublime, command])
|
|
|
|
elif 0 <= editor_atom.find('atom.exe'):
|
|
start = editor_atom.find('\n') + 1
|
|
end = editor_atom.find('\n',start + 5) -4
|
|
editor_atom = editor_atom[ start : end]
|
|
command = file_path + ':' + str(line_num) + ':' + str(column_num)
|
|
subprocess.Popen([editor_atom, command])
|
|
|
|
else:
|
|
os.startfile(resolve_path(path)) # open file with default app
|
|
|
|
elif current_OS == 'Linux':
|
|
|
|
command = file_path + ':' + str(line_num) + ':' + str(column_num)
|
|
index_end = command.find(',')
|
|
if 0 <= index_end:
|
|
command = command[ : index_end] # sometimes a comma magically appears, don't want it
|
|
running_apps = subprocess.Popen('ps ax -o cmd', stdout=subprocess.PIPE, shell=True)
|
|
(output, err) = running_apps.communicate()
|
|
temp = output.split('\n')
|
|
|
|
def find_editor_linux(name, search_obj):
|
|
for line in search_obj:
|
|
if 0 <= line.find(name):
|
|
path = line
|
|
return True, path
|
|
return False , ''
|
|
|
|
(success_sublime, editor_path_sublime) = find_editor_linux('sublime_text',temp)
|
|
(success_atom, editor_path_atom) = find_editor_linux('atom',temp)
|
|
|
|
if success_sublime:
|
|
subprocess.Popen([editor_path_sublime, command])
|
|
|
|
elif success_atom:
|
|
subprocess.Popen([editor_path_atom, command])
|
|
|
|
else:
|
|
os.system('xdg-open ' + file_path )
|
|
|
|
elif current_OS == 'Darwin': # MAC
|
|
|
|
command = file_path + ':' + str(line_num) + ':' + str(column_num)
|
|
index_end = command.find(',')
|
|
if 0 <= index_end:
|
|
command = command[ : index_end] # sometimes a comma magically appears, don't want it
|
|
running_apps = subprocess.Popen('ps axwww -o command', stdout=subprocess.PIPE, shell=True)
|
|
(output, err) = running_apps.communicate()
|
|
temp = output.split('\n')
|
|
|
|
def find_editor_mac(name, search_obj):
|
|
for line in search_obj:
|
|
if 0 <= line.find(name):
|
|
path = line
|
|
if 0 <= path.find('-psn'):
|
|
path = path[ : path.find('-psn') - 1 ]
|
|
return True, path
|
|
return False , ''
|
|
|
|
(success_sublime, editor_path_sublime) = find_editor_mac('Sublime',temp)
|
|
(success_atom, editor_path_atom) = find_editor_mac('Atom',temp)
|
|
|
|
if success_sublime:
|
|
subprocess.Popen([editor_path_sublime, command])
|
|
|
|
elif success_atom:
|
|
subprocess.Popen([editor_path_atom, command])
|
|
|
|
else:
|
|
os.system('open ' + file_path )
|
|
# end - open_file
|
|
|
|
|
|
# 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 0 <= name.find('.') or 0 <= name.find('-'): # skip files in listing
|
|
continue
|
|
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()
|
|
|
|
env_A = ''
|
|
env_B = ''
|
|
env_C = ''
|
|
|
|
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()
|
|
PIO_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
|
|
line_counter = 0
|
|
|
|
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
|
|
global line_counter
|
|
|
|
|
|
|
|
|
|
# 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:
|
|
r_loc = text.find('\r') + 1
|
|
if r_loc > 0 and r_loc < len(text): # need to split this line
|
|
text = text.split('\r')
|
|
for line in text:
|
|
write_to_screen_queue(line + '\n')
|
|
else:
|
|
write_to_screen_queue(text + '\n')
|
|
# end - write_to_screen_with_replace
|
|
|
|
|
|
|
|
# scan the line
|
|
line_counter = line_counter + 1
|
|
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 0 < line_input.find('Thank you') or 0 < line_input.find('SUMMARY') :
|
|
warning = False #standard line found
|
|
warning_FROM = False
|
|
error = False
|
|
standard = True
|
|
prev_line_COM = False
|
|
warning_continue = False
|
|
elif 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 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 beginning == 'fro' and warning == True or \
|
|
beginning == '.pi' : # start of warning /error block
|
|
warning_FROM = True
|
|
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 or an error
|
|
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):
|
|
# based on Super Text
|
|
global continue_updates
|
|
continue_updates = True
|
|
|
|
global search_position
|
|
search_position = '' # start with invalid search position
|
|
|
|
global error_found
|
|
error_found = False # are there any errors?
|
|
|
|
global memory_check_first_time
|
|
memory_check_first_time = True # wants to run memory_check twice
|
|
|
|
|
|
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(background = 'black', foreground = 'white', font= ("consolas", 12), wrap = 'none', undo = 'True')
|
|
self.config(height = 24, width = 100)
|
|
self.config(insertbackground = 'pale green') # keyboard insertion point
|
|
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.tag_config('error_highlight_inactive', background = 'dim gray')
|
|
self.tag_config('error_highlight_active', background = 'light grey')
|
|
|
|
self.bind_class("Text","<Control-a>", self.select_all) # required in windows, works in others
|
|
self.bind_all("<Control-Shift-E>", self.scroll_errors)
|
|
self.bind_class("<Control-Shift-R>", self.rebuild)
|
|
|
|
# scrollbar
|
|
|
|
scrb = tk.Scrollbar(self.frame, orient='vertical', command=self.yview)
|
|
self.config(yscrollcommand=scrb.set)
|
|
scrb.pack(side='right', fill='y')
|
|
|
|
# self.scrb_Y = tk.Scrollbar(self.frame, orient='vertical', command=self.yview)
|
|
# self.scrb_Y.config(yscrollcommand=self.scrb_Y.set)
|
|
# self.scrb_Y.pack(side='right', fill='y')
|
|
#
|
|
# self.scrb_X = tk.Scrollbar(self.frame, orient='horizontal', command=self.xview)
|
|
# self.scrb_X.config(xscrollcommand=self.scrb_X.set)
|
|
# self.scrb_X.pack(side='bottom', fill='x')
|
|
|
|
# scrb_X = tk.Scrollbar(self, orient=tk.HORIZONTAL, command=self.xview) # tk.HORIZONTAL now have a horizsontal scroll bar BUT... shrinks it to a postage stamp and hides far right behind the vertical scroll bar
|
|
# self.config(xscrollcommand=scrb_X.set)
|
|
# scrb_X.pack(side='bottom', fill='x')
|
|
#
|
|
# scrb= tk.Scrollbar(self, orient='vertical', command=self.yview)
|
|
# self.config(yscrollcommand=scrb.set)
|
|
# scrb.pack(side='right', fill='y')
|
|
|
|
# self.config(height = 240, width = 1000) # didn't get the size baCK TO NORMAL
|
|
# self.pack(side='left', fill='both', expand=True) # didn't get the size baCK TO NORMAL
|
|
|
|
|
|
# pop-up menu
|
|
self.popup = tk.Menu(self, tearoff=0)
|
|
|
|
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='Cut', command=self._cut)
|
|
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.popup.add_separator()
|
|
# self.popup.add_command(label='Repeat Build(CTL-shift-r)', command=self._rebuild)
|
|
self.popup.add_command(label='Repeat Build', command=self._rebuild)
|
|
self.popup.add_separator()
|
|
self.popup.add_command(label='Scroll Errors (CTL-shift-e)', command=self._scroll_errors)
|
|
self.popup.add_separator()
|
|
self.popup.add_command(label='Open File at Cursor', command=self._open_selected_file)
|
|
|
|
if current_OS == 'Darwin': # MAC
|
|
self.bind('<Button-2>', self._show_popup) # macOS only
|
|
else:
|
|
self.bind('<Button-3>', self._show_popup) # Windows & Linux
|
|
|
|
|
|
# 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(10, self.check_thread)
|
|
|
|
|
|
def update(self):
|
|
global continue_updates
|
|
if continue_updates == True:
|
|
self.root.after(10, 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.memory_check() # scan buffer and add percent used if needed
|
|
print 'starting memory check'
|
|
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 _scroll_errors(self):
|
|
global search_position
|
|
global error_found
|
|
if search_position == '': # first time so highlight all errors
|
|
countVar = tk.IntVar()
|
|
search_position = '1.0'
|
|
search_count = 0
|
|
while not(search_position == '') and search_count < 100:
|
|
search_position = self.search("error", search_position, stopindex="end", count=countVar, nocase=1)
|
|
search_count = search_count + 1
|
|
if not(search_position == ''):
|
|
error_found = True
|
|
end_pos = '{}+{}c'.format(search_position, 5)
|
|
self.tag_add("error_highlight_inactive", search_position, end_pos)
|
|
search_position = '{}+{}c'.format(search_position, 1) # point to the next character for new search
|
|
else:
|
|
break
|
|
|
|
if error_found:
|
|
if search_position == '':
|
|
search_position = self.search("error", '1.0', stopindex="end", nocase=1) # new search
|
|
else: # remove active highlight
|
|
end_pos = '{}+{}c'.format(search_position, 5)
|
|
start_pos = '{}+{}c'.format(search_position, -1)
|
|
self.tag_remove("error_highlight_active", start_pos, end_pos)
|
|
search_position = self.search("error", search_position, stopindex="end", nocase=1) # finds first occurrence AGAIN on the first time through
|
|
if search_position == "": # wrap around
|
|
search_position = self.search("error", '1.0', stopindex="end", nocase=1)
|
|
end_pos = '{}+{}c'.format(search_position, 5)
|
|
self.tag_add("error_highlight_active", search_position, end_pos) # add active highlight
|
|
self.see(search_position)
|
|
search_position = '{}+{}c'.format(search_position, 1) # point to the next character for new search
|
|
|
|
def scroll_errors(self, event):
|
|
self._scroll_errors()
|
|
|
|
|
|
def _rebuild(self):
|
|
#global board_name
|
|
#global Marlin_ver
|
|
#global target_env
|
|
#board_name, Marlin_ver = get_board_name()
|
|
#target_env = get_env(board_name, Marlin_ver)
|
|
self.start_thread()
|
|
|
|
def rebuild(self, event):
|
|
print "event happened"
|
|
self._rebuild()
|
|
|
|
|
|
def _open_selected_file(self):
|
|
current_line = self.index('insert')
|
|
line_start = current_line[ : current_line.find('.')] + '.0'
|
|
line_end = current_line[ : current_line.find('.')] + '.200'
|
|
self.mark_set("path_start", line_start)
|
|
self.mark_set("path_end", line_end)
|
|
path = self.get("path_start", "path_end")
|
|
from_loc = path.find('from ')
|
|
colon_loc = path.find(': ')
|
|
if 0 <= from_loc and ((colon_loc == -1) or (from_loc < colon_loc)) :
|
|
path = path [ from_loc + 5 : ]
|
|
if 0 <= colon_loc:
|
|
path = path [ : colon_loc ]
|
|
if 0 <= path.find('\\') or 0 <= path.find('/'): # make sure it really contains a path
|
|
open_file(path)
|
|
|
|
|
|
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):
|
|
self._cut()
|
|
|
|
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):
|
|
self._copy()
|
|
|
|
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')
|
|
|
|
# add memory % if needed
|
|
def memory_check(self):
|
|
global memory_check_first_time
|
|
if not(memory_check_first_time):
|
|
return
|
|
memory_check_first_time = False
|
|
search_position = self.search("Environment used:", "1.0", stopindex="end")
|
|
env_line = self.get(search_position, '{}+{}c'.format(search_position, 200))
|
|
print 'env_line 1 ', env_line
|
|
if 0 <= env_line.find('\n'):
|
|
env_line = env_line[ : env_line.find('\n')]
|
|
env_end = env_line.find(' ', 18)
|
|
if env_end == -1:
|
|
env_end = len(env_line)
|
|
env_line = env_line[ 18 : env_end ]
|
|
print 'env_line 2 ', env_line
|
|
env_found = False
|
|
for env in mem_check_environments:
|
|
if env_line == env:
|
|
env_found = True
|
|
print 'env ', env
|
|
|
|
search_position = self.search("Build type:", "1.0", stopindex="end")
|
|
if search_position == "":
|
|
print "didn't find it"
|
|
return
|
|
build_line = self.get(search_position, '{}+{}c'.format(search_position, 200))
|
|
print 'build_line 1 ', build_line
|
|
if 0 <= build_line.find('\n'):
|
|
build_line = build_line[ : build_line.find('\n')]
|
|
build_end = build_line.find(' ', 14)
|
|
if build_end == -1:
|
|
build_end = len(build_line)
|
|
build_line = build_line[ 12 : build_end ]
|
|
print 'build_line 2 ', build_line
|
|
build_found = False
|
|
for build in mem_check_builds:
|
|
if build_line == build:
|
|
build_found = True
|
|
print 'build ', build
|
|
|
|
if env_found and build_found: # find the memory values
|
|
search_position = self.search("Checking program size", "1.0", stopindex="end")
|
|
if search_position != '':
|
|
print 'search_position: ' + search_position
|
|
line_int = int(search_position[ : search_position.find(".")]) + 1
|
|
line_str = str(line_int)
|
|
line = self.get(line_str + '.0', line_str + '.200')
|
|
print 'line: ', line
|
|
while 'text' != line[ : 4 ] :
|
|
line_int = line_int + 1
|
|
line_str = str(line_int)
|
|
line = self.get(line_str + '.0', line_str + '.200')
|
|
print 'line: ', line
|
|
line_int = line_int + 1
|
|
line_str = str(line_int)
|
|
print 'line + 3: ' + line_str + '.0'
|
|
size_line = self.get(line_str + '.0', line_str + '.200')
|
|
print 'size_line ', size_line
|
|
|
|
data_start = 0
|
|
while ' ' == size_line[ data_start : data_start + 1] :
|
|
data_start = data_start + 1 # eat leading blanks
|
|
print 'data_start: ', data_start, size_line.find(' ', data_start)
|
|
data_end = size_line.find(' ', data_start) - 1
|
|
text_str = size_line[ data_start : data_end]
|
|
print 'text_str = ', data_start, data_end, text_str + '/////'
|
|
text_val = int(text_str)
|
|
print 'text_val ', text_val
|
|
|
|
data_start = size_line.find(' ', data_end)
|
|
while ' ' == size_line[ data_start : data_start + 1] :
|
|
data_start = data_start + 1 # eat leading blanks
|
|
print 'data_start: ', data_start, size_line.find(' ', data_start)
|
|
data_end = size_line.find(' ', data_start) -1
|
|
data_val = int(size_line[ data_start : data_end])
|
|
print 'data_val ', data_val
|
|
|
|
data_start = size_line.find(' ', data_end)
|
|
while ' ' == size_line[ data_start : data_start + 1] :
|
|
data_start = data_start + 1 # eat leading blanks
|
|
print 'data_start: ', data_start, size_line.find(' ', data_start)
|
|
data_end = size_line.find(' ', data_start) - 1
|
|
if data_end == -1:
|
|
data_end = len(size_line)
|
|
bss_val = int(size_line[ data_start : data_end])
|
|
print 'bss_val ', bss_val
|
|
|
|
FLASH_total = text_val + data_val
|
|
RAM_total = bss_val + data_val
|
|
|
|
tag = 'normal'
|
|
if FLASH_total >= FLASH_MAX * FLASH_PERCENT_WARN:
|
|
tag = 'warning'
|
|
if FLASH_total >= FLASH_MAX:
|
|
tag = 'error'
|
|
line_int = line_int + 1
|
|
line_str = str(line_int)
|
|
self.insert('end', '\nProgram: ' + str(FLASH_total) + ' bytes (' + str( 100*FLASH_total/FLASH_MAX) + '% of application area)\n', tag)
|
|
self.insert(line_str + '.0', '\nProgram: ' + str(FLASH_total) + ' bytes (' + str( 100*FLASH_total/FLASH_MAX) + '% of application area)\n', tag)
|
|
|
|
|
|
tag = 'normal'
|
|
if RAM_total >= RAM_MAX - RAM_WARN:
|
|
tag = 'warning'
|
|
if RAM_total >= RAM_MAX - RAM_SYSTEM:
|
|
tag = 'error'
|
|
line_int = line_int + 2
|
|
line_str = str(line_int)
|
|
self.insert('end', 'Data: ' + str(RAM_total) + ' bytes (' + str( 100*RAM_total/(RAM_MAX-RAM_SYSTEM)) + '% of non-system RAM)\n', tag)
|
|
self.insert(line_str + '.0', 'Data: ' + str(RAM_total) + ' bytes (' + str( 100*RAM_total/(RAM_MAX-RAM_SYSTEM)) + '% of non-system RAM)\n\n', tag)
|
|
self.see("end") # make the new lines visible (scroll text off the top)
|
|
# end - memory_check
|
|
|
|
|
|
#
|
|
# error reporting proceedure for copy_boards_dir()
|
|
#
|
|
def report_failure(self, PIO_path, board_path):
|
|
# didn't find the file - user needs to copy it & re-run the script
|
|
self.insert('end', 'Unable to move board definition file to destination. User must manually copy the file.\n\n', 'error')
|
|
self.insert('end', 'Please copy the following file and re-run the script:\n', 'normal')
|
|
self.insert('end', ' FROM:\n')
|
|
self.insert('end', ' ' + pwd + '/' + board_path + '/at90usb1286.json\n')
|
|
self.insert('end', ' TO:\n')
|
|
self.insert('end', ' ' + PIO_path + '/at90usb1286.json\n')
|
|
|
|
|
|
|
|
#
|
|
# move custom board definitions from project folder to PlatformIO
|
|
# returns True if the file ends up in the correct location
|
|
#
|
|
def copy_boards_dir(self):
|
|
|
|
temp = os.environ
|
|
for key in temp:
|
|
if 0 <= os.environ[key].find('.platformio'):
|
|
part = os.environ[key].split(';')
|
|
for part2 in part:
|
|
if 0 <= part2.find('.platformio'):
|
|
path = part2
|
|
break
|
|
|
|
path = path.replace("\\", "/")
|
|
path = path.replace("//", "/")
|
|
|
|
path_remaining = path
|
|
still_looking = True
|
|
PIO_path = ''
|
|
while still_looking:
|
|
colon_pos = path_remaining.find(':')
|
|
if -1 == colon_pos:
|
|
still_looking = False
|
|
path_maybe = path_remaining
|
|
else:
|
|
path_maybe = path_remaining[ : colon_pos]
|
|
path_remaining = path_remaining[ colon_pos + 1 : ]
|
|
if 0 <= path_maybe.find('/.platformio'):
|
|
still_looking = False
|
|
PIO_path = path_maybe
|
|
|
|
start_loc = PIO_path.find('/.platformio')
|
|
next_loc = PIO_path.find('/', start_loc + 5)
|
|
if 0 <= next_loc:
|
|
PIO_path = PIO_path[ : next_loc]
|
|
PIO_path = PIO_path + '/boards'
|
|
|
|
board_path = 'buildroot/share/PlatformIO/boards'
|
|
|
|
from distutils.dir_util import copy_tree
|
|
try:
|
|
copy_tree(board_path, PIO_path)
|
|
except:
|
|
pass
|
|
# check to see if it's there
|
|
# macOS will throw an exception if it can't get to the directory
|
|
# Ubuntu doesn't complain if it can't get to the directory
|
|
# Windows always succeeds (have not been able to lock it out in testing)
|
|
short_path = PIO_path[ : PIO_path.find('/boards')]
|
|
try:
|
|
PIO_dir = os.listdir(short_path)
|
|
except:
|
|
self.report_failure(PIO_path, board_path)
|
|
return False
|
|
if 'boards' in PIO_dir:
|
|
try:
|
|
boards_dir = os.listdir(PIO_path)
|
|
except:
|
|
self.report_failure(PIO_path, board_path)
|
|
return False
|
|
if 'at90usb1286.json' in boards_dir:
|
|
return True # it's there so all is well
|
|
self.report_failure(PIO_path, board_path)
|
|
return False
|
|
# end copy_boards_dir
|
|
|
|
# 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)
|
|
|
|
os.environ["BUILD_TYPE"] = build_type # let sub processes know what is happening
|
|
os.environ["TARGET_ENV"] = target_env
|
|
os.environ["BOARD_NAME"] = board_name
|
|
|
|
auto_build = output_window()
|
|
|
|
continue_script = True
|
|
if 0 <= target_env.find('USB1286'):
|
|
continue_script = auto_build.copy_boards_dir() # copy custom boards over to PlatformIO if using custom board
|
|
|
|
if continue_script:
|
|
auto_build.start_thread() # executes the "run_PIO" function
|
|
|
|
auto_build.root.mainloop()
|
|
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
|
main()
|