auto_build Namespace Reference

Classes
class	output_window

Functions
def	get_answer (board_name, cpu_label_txt, cpu_a_txt, cpu_b_txt)
	Python 2 error messages: Can't find a usable init.tcl in the following directories ... More...
def	resolve_path (path)
def	open_file (path)
def	get_build_last ()
def	get_board_name ()
def	get_env_from_line (line, start_position)
def	get_starting_env (board_name_full, version)
def	get_CPU_name (environment)
def	get_env (board_name, ver_Marlin)
def	write_to_screen_queue (text, format_tag='normal')
def	line_print (line_input)
def	sys_PIO ()
def	run_PIO (dummy)
def	main ()

Variables
	pwd = os.getcwd()
	num_args = len(sys.argv)
	build_type = str(sys.argv[1])
	python_ver = sys.version_info[0]
	current_OS = platform.system()
string	target_env = ''
string	board_name = ''
	IO_queue = queue.Queue()
bool	warning = False
bool	warning_FROM = False
bool	error = False
bool	standard = True
bool	prev_line_COM = False
bool	next_line_warning = False
bool	warning_continue = False
int	line_counter = 0
	que = queue.Queue()

Function Documentation

get_answer()

def auto_build.get_answer	(		board_name,
			cpu_label_txt,
			cpu_a_txt,
			cpu_b_txt
	)

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 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.attributes("-topmost", True)
 
        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
#

Here is the caller graph for this function:

resolve_path()

def auto_build.resolve_path

(

path

)

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 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 start != 0:                  # 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)
#

Here is the caller graph for this function:

open_file()

def auto_build.open_file

(

path

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_build_last()

def auto_build.get_build_last

(

)

def get_build_last():
      env_last = ''
      DIR_PWD = os.listdir('.')
      if '.pio' in DIR_PWD:
        date_last = 0.0
        DIR__pioenvs = os.listdir('.pio')
        for name in DIR__pioenvs:
          if 0 <= name.find('.') or 0 <= name.find('-'):   # skip files in listing
            continue
          DIR_temp = os.listdir('.pio/build/' + name)
          for names_temp in DIR_temp:
 
            if 0 == names_temp.find('firmware.'):
              date_temp = os.path.getmtime('.pio/build/' + 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)

Here is the caller graph for this function:

get_board_name()

def auto_build.get_board_name

(

)

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

Here is the caller graph for this function:

get_env_from_line()

def auto_build.get_env_from_line	(		line,
			start_position
	)

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

Here is the caller graph for this function:

get_starting_env()

def auto_build.get_starting_env	(		board_name_full,
			version
	)

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_CPU_name()

def auto_build.get_CPU_name

(

environment

)

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

Here is the caller graph for this function:

get_env()

def auto_build.get_env	(		board_name,
			ver_Marlin
	)

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 target_env != 'LPC1768_debug_and_upload' and 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

Here is the call graph for this function:

Here is the caller graph for this function:

write_to_screen_queue()

def auto_build.write_to_screen_queue	(		text,
			format_tag = 'normal'
	)

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

Here is the caller graph for this function:

line_print()

def auto_build.line_print

(

line_input

)

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'],
              ['[IGNORED]', 1, 'warning'],
              ['[ERROR]', 1, 'error'],
              ['[FAILED]', 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' + '\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:
              if line != '':
                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
 
 

Here is the call graph for this function:

Here is the caller graph for this function:

sys_PIO()

def auto_build.sys_PIO

(

)

                                                                   #

run Platformio # #

def sys_PIO():
 
    ##########################################################################
    #                                                                        #
    # run Platformio inside the same shell as this Python script             #
    #                                                                        #
    ##########################################################################
 
    global build_type
    global target_env
 
    import os
 
    print('build_type: ', build_type)
    print('starting platformio')
 
    if   build_type == 'build':
          # pio_result = os.system("echo -en '\033c'")
          pio_result = os.system('platformio run -e ' + target_env)
    elif build_type == 'clean':
          pio_result = os.system('platformio run --target clean -e ' + target_env)
    elif build_type == 'upload':
          pio_result = os.system('platformio run --target upload -e ' + target_env)
    elif build_type == 'traceback':
          pio_result = os.system('platformio run --target upload -e ' + target_env)
    elif build_type == 'program':
          pio_result = os.system('platformio run --target program -e ' + target_env)
    elif build_type == 'test':
          pio_result = os.system('platformio test upload -e ' + target_env)
    elif build_type == 'remote':
          pio_result = os.system('platformio remote run --target program -e ' + target_env)
    elif build_type == 'debug':
          pio_result = os.system('platformio debug -e ' + target_env)
    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')
    #  write_to_screen_queue(str(datetime.now()) + '\n')
 
# end - sys_PIO
 
 
 

Here is the caller graph for this function:

run_PIO()

def auto_build.run_PIO

(

dummy

)

def run_PIO(dummy):
 
    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
    if python_ver == 2:
        for line in iter(pio_subprocess.stdout.readline, ''):
            line_print(line.replace('\n', ''))
    else:
        for line in iter(pio_subprocess.stdout.readline, b''):
            line = line.decode('utf-8')
            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')
    write_to_screen_queue(str(datetime.now()) + '\n')
 
# end - run_PIO
 
 
 

Here is the call graph for this function:

main()

def auto_build.main

(

void

)

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)
 
    # Re-use the VSCode terminal, if possible
    if os.environ.get('PLATFORMIO_CALLER', '') == 'vscode':
        sys_PIO()
    else:
        auto_build = output_window()
        auto_build.start_thread()  # executes the "run_PIO" function
 
        auto_build.root.mainloop()
 
 
 

Here is the call graph for this function:

Variable Documentation

pwd

auto_build.pwd = os.getcwd()

num_args

auto_build.num_args = len(sys.argv)

build_type

auto_build.build_type = str(sys.argv[1])

python_ver

auto_build.python_ver = sys.version_info[0]

current_OS

auto_build.current_OS = platform.system()

target_env

string auto_build.target_env = ''

board_name

string auto_build.board_name = ''

IO_queue

auto_build.IO_queue = queue.Queue()

warning

bool auto_build.warning = False

warning_FROM

bool auto_build.warning_FROM = False

error

bool auto_build.error = False

standard

bool auto_build.standard = True

prev_line_COM

bool auto_build.prev_line_COM = False

next_line_warning

bool auto_build.next_line_warning = False

warning_continue

bool auto_build.warning_continue = False

line_counter

int auto_build.line_counter = 0

que

auto_build.que = queue.Queue()