initial commit

.gitattributes

@@ -1,3 +1,12 @@
+venv/
+.env
+__pycache__/
+error_log.txt
+.cache
+tcc_ceds_music.csv
+.pyc
+
+
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
@@ -33,3 +42,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+
+
+

README.md

@@ -5,7 +5,7 @@ colorFrom: green
 colorTo: pink
 sdk: gradio
 sdk_version: 5.6.0
-app_file: app.py
+app_file: gcode_analyzer_ui.py
 pinned: false
 short_description: verify and analyze your G-codes
 ---

gcode_analyzer_ui.py

@@ -0,0 +1,60 @@
+# gcode_analyzer_ui.py
+
+import gradio as gr
+from python_gcode_checker import run_checks
+from settings_report_details import generate_detailed_report
+
+def analyze_gcode(gcode, depth_max=0.1):
+    errors, warnings = run_checks(gcode, depth_max)
+    error_count = len(errors)
+    warning_count = len(warnings)
+    config_report = generate_detailed_report(gcode)
+    return f"Errors: {error_count}\n\n{format_issues(errors)}", f"Warnings: {warning_count}\n\n{format_issues(warnings)}", config_report
+
+def format_issues(issues):
+    formatted = []
+    for line_num, message in issues:
+        if line_num > 0:
+            formatted.append(f"Line {line_num}: {message}")
+        else:
+            formatted.append(message)
+    return "\n".join(formatted)
+
+with gr.Blocks() as app:
+    # Customized introduction and instructions for users
+    gr.Markdown("""
+    ### G-code Programming Assistant (v0.1)
+    
+    Welcome to the G-code Assistant! This tool is solely for educational purposes, helping you verify and analyze your G-code for potential errors and warnings before actually running it on your machine. 
+    
+    **Note:** This tool is limited to simple carving operations on a CNC milling machine.
+    
+    This is a beta version, and you're free to use it for checking your G-codes. If you encounter any issues or unexpected behavior, please contact the developer at **nico.aspra@bicol-u.edu.ph**.
+    """)
+
+    # Depth input at the top
+    depth_input = gr.Number(value=0.1, label="Maximum Depth of Cut", precision=1)
+    
+    # G-code input textbox
+    gcode_input = gr.Textbox(lines=20, label="Input G-code", placeholder="Enter G-code here...")
+
+    # Analyze button positioned immediately after G-code input
+    analyze_button = gr.Button("Analyze G-code")
+
+    # Output sections displayed below the Analyze button
+    with gr.Row():
+        output_errors = gr.Textbox(label="Errors", interactive=False)
+        output_warnings = gr.Textbox(label="Warnings", interactive=False)
+    output_config = gr.Textbox(label="Configuration Settings", interactive=False)
+
+    # Define the button click functionality
+    analyze_button.click(
+        fn=analyze_gcode,
+        inputs=[gcode_input, depth_input],
+        outputs=[output_errors, output_warnings, output_config]
+    )
+
+    gr.Markdown("---")
+    gr.Markdown("Developed by **Aspra, N.**")
+
+app.launch()

python_gcode_checker.py

@@ -0,0 +1,444 @@
+import re
+from decimal import Decimal, getcontext
+import decimal
+
+# Define interpolation and movement commands
+interpolation_commands = {"G01", "G02", "G03"}
+movement_commands = {"G00"}
+
+# Define a pattern to recognize common G-code commands
+gcode_pattern = re.compile(
+    r"(G\d+|M\d+|X[-+]?\d*\.?\d+|Y[-+]?\d*\.?\d+|"
+    r"Z[-+]?\d*\.?\d+|I[-+]?\d*\.?\d+|J[-+]?\d*\.?\d+|"
+    r"F[-+]?\d*\.?\d+|S[-+]?\d*\.?\d+)"
+)
+
+def standardize_codes(line):
+    """
+    Standardizes M-codes and G-codes to two digits by adding a leading zero if necessary.
+    """
+    line = re.sub(r"\b(M|G)(\d)\b", r"\g<1>0\2", line)
+    return line
+
+def remove_comments(line):
+    """
+    Removes comments from a G-code line. Supports both ';' and '()' style comments.
+    """
+    # Remove anything after a ';'
+    line = line.split(';')[0]
+    # Remove anything inside parentheses '()'
+    line = re.sub(r'\(.*?\)', '', line)
+    return line.strip()
+
+def preprocess_gcode(gcode):
+    """
+    Removes comments from the G-code and returns a list of tuples (original_line_number, cleaned_line).
+    Includes all lines to maintain accurate line numbering.
+    """
+    cleaned_lines = []
+    lines = gcode.splitlines()
+
+    for idx, line in enumerate(lines):
+        original_line_number = idx + 1  # Line numbers start from 1
+        line = standardize_codes(line.strip())
+        # Remove comments
+        line_no_comments = remove_comments(line)
+        # Include all lines to maintain accurate line numbering
+        cleaned_lines.append((original_line_number, line_no_comments))
+
+    return cleaned_lines
+
+def check_required_gcodes(lines_with_numbers):
+    """
+    Checks that the G-code contains required G-codes: G20/G21, G90/G91, G54-G59, and G17.
+    Returns a list of errors with individual entries for each missing group.
+    """
+    required_groups = {
+        "units": {"G20", "G21"},
+        "mode": {"G90", "G91"},
+        "work_coordinates": {"G54", "G55", "G56", "G57", "G58", "G59"},
+        "plane": {"G17", "G18", "G19"},
+    }
+
+    # Create a set to track found codes and their line numbers
+    found_codes = {}
+    for original_line_number, line in lines_with_numbers:
+        tokens = line.split()
+        for token in tokens:
+            found_codes.setdefault(token, original_line_number)  # Record the line number where the code was found
+
+    # List to hold individual errors for each missing group
+    missing_group_errors = []
+    
+    # Check for presence of required codes
+    for category, codes in required_groups.items():
+        found = any(code in found_codes for code in codes)
+        if not found:
+            missing_codes = "/".join(sorted(codes))
+            # Assume missing codes should be on the first line where G-codes start
+            for original_line_number, line in lines_with_numbers:
+                if gcode_pattern.search(line):
+                    missing_group_errors.append((original_line_number, f"(Error) Missing required G-codes: ({category}) {missing_codes}"))
+                    break
+            else:
+                # Default to line 1 if no G-code commands are found
+                missing_group_errors.append((1, f"(Error) Missing required G-codes: ({category}) {missing_codes}"))
+
+    return missing_group_errors
+
+def check_end_gcode(lines_with_numbers):
+    """
+    Checks that M30 is the last G-code command.
+    Allows blank lines or '%' symbols after M30.
+    """
+    found_m30 = False
+
+    # Collect errors with line numbers
+    errors = []
+
+    for idx, (original_line_number, line) in enumerate(lines_with_numbers):
+        if not line.strip() or line.strip() == "%":
+            continue  # Skip empty lines or lines with only '%'
+
+        if "M30" in line:
+            if found_m30:
+                errors.append((original_line_number, "(Error) M30 must be the last G-code command in the G-code."))
+            found_m30 = True
+            continue  # Continue to check if any G-code commands appear after M30
+
+        # After M30, no other G-code commands should appear
+        if found_m30 and gcode_pattern.search(line):
+            errors.append((original_line_number, f"(Error) No G-code commands should appear after M30. Found '{line.strip()}'."))
+    
+    if not found_m30:
+        if lines_with_numbers:
+            last_line_number = lines_with_numbers[-1][0]
+        else:
+            last_line_number = 1
+        errors.append((last_line_number, "(Error) M30 is missing from the G-code."))
+
+    return errors
+
+def check_spindle(lines_with_numbers):
+    """
+    Checks spindle-related issues in the G-code.
+    """
+    issues = []
+    spindle_on = False
+    spindle_started = False
+
+    for idx, (original_line_number, line) in enumerate(lines_with_numbers):
+        # Skip processing lines that are empty or contain only '%'
+        if not line.strip() or line.strip() == "%":
+            continue
+
+        tokens = line.split()
+
+        # Check for valid G-code commands
+        if not gcode_pattern.search(line):
+            issues.append((original_line_number, f"(Error) Invalid G-code command or syntax error -> {line.strip()}"))
+
+        # Check for spindle on
+        if "M03" in tokens or "M04" in tokens:
+            # Check if spindle is already on
+            if spindle_on:
+                issues.append((original_line_number, "(Warning) Spindle is already on."))
+
+            # Check if spindle speed is specified with 'S' command
+            s_value_present = any(token.startswith("S") for token in tokens)
+            if not s_value_present:
+                issues.append((original_line_number, "(Error) Spindle speed (S value) is missing when turning on the spindle with M03/M04."))
+
+            spindle_on = True
+            spindle_started = True
+
+        # Check for spindle off
+        if "M05" in tokens:
+            spindle_on = False
+
+        # Check if movement commands are given without spindle on
+        if any(cmd in tokens for cmd in interpolation_commands):
+            if not spindle_on:
+                issues.append((original_line_number, f"(Error) Move command without spindle on -> {line.strip()}"))
+
+    # Check if spindle was turned off before M30
+    if spindle_on:
+        last_line_number = lines_with_numbers[-1][0]
+        issues.append((last_line_number, "(Error) Spindle was not turned off (M05) before the end of the program."))
+
+    # Check if spindle was never turned on
+    if not spindle_started:
+        issues.append((0, "(Error) Spindle was never turned on in the G-code."))
+
+    return issues
+
+def check_feed_rate(lines_with_numbers):
+    """
+    Checks feed rate related issues in the G-code.
+    """
+    issues = []
+    last_feed_rate = None
+    interpolation_command_seen = False
+
+    for idx, (original_line_number, line) in enumerate(lines_with_numbers):
+        # Skip processing lines that are empty or contain only '%'
+        if not line.strip() or line.strip() == "%":
+            continue
+
+        tokens = line.split()
+        commands = set(tokens)
+        feed_rates = [token for token in tokens if token.startswith("F")]
+
+        # Check if feed rate is beside non-interpolation commands
+        if feed_rates and not any(cmd in interpolation_commands for cmd in commands):
+            issues.append((original_line_number, f"(Warning) Feed rate specified without interpolation command -> {line.strip()}"))
+
+        # Check for interpolation commands
+        if any(cmd in commands for cmd in interpolation_commands):
+            if not interpolation_command_seen:
+                interpolation_command_seen = True
+                if not feed_rates and last_feed_rate is None:
+                    issues.append((original_line_number, f"(Error) First interpolation command must have a feed rate -> {line.strip()}"))
+                else:
+                    # Set initial feed rate
+                    if feed_rates:
+                        last_feed_rate = feed_rates[-1]
+            else:
+                # Check if feed rate is specified
+                if feed_rates:
+                    current_feed_rate = feed_rates[-1]
+                    if current_feed_rate == last_feed_rate:
+                        issues.append((original_line_number, f"(Warning) Feed rate {current_feed_rate} is already set; no need to specify again."))
+                    else:
+                        last_feed_rate = current_feed_rate
+
+    return issues
+
+def check_depth_of_cut(lines_with_numbers, depth_max=0.1):
+    """
+    Checks that all cutting moves on the Z-axis have a uniform depth and do not exceed the maximum depth.
+    """
+    getcontext().prec = 6  # Set precision as needed
+    depth_max = Decimal(str(depth_max))
+    issues = []
+
+    positioning_mode = "G90"  # Default to absolute positioning
+    current_z = Decimal('0.0')
+    depths = set()
+    z_negative_seen = False
+
+    for idx, (original_line_number, line) in enumerate(lines_with_numbers):
+        # Skip processing lines that are empty or contain only '%'
+        if not line.strip() or line.strip() == "%":
+            continue
+
+        tokens = line.split()
+
+        if "G90" in tokens:
+            positioning_mode = "G90"
+        elif "G91" in tokens:
+            positioning_mode = "G91"
+
+        if any(cmd in tokens for cmd in interpolation_commands.union(movement_commands)):
+            z_values = [token for token in tokens if token.startswith("Z")]
+            if z_values:
+                try:
+                    z_value = Decimal(z_values[-1][1:])
+                except (ValueError, decimal.InvalidOperation):
+                    issues.append((original_line_number, f"(Error) Invalid Z value -> {line.strip()}"))
+                    continue
+
+                if positioning_mode == "G90":
+                    new_z = z_value
+                elif positioning_mode == "G91":
+                    new_z = current_z + z_value
+
+                if new_z < Decimal('0.0'):
+                    z_negative_seen = True
+                    depth = abs(new_z)
+                    depth = depth.quantize(Decimal('0.0001')).normalize()  # Round and remove trailing zeros
+                    depths.add(depth)
+
+                    if depth > depth_max:
+                        issues.append((original_line_number, f"(Error) Depth of cut {depth} exceeds maximum allowed depth of {depth_max.normalize()} -> {line.strip()}"))
+
+                current_z = new_z
+
+    if z_negative_seen:
+        if len(depths) > 1:
+            depth_values = ', '.join(str(d.normalize()) for d in sorted(depths))
+            issues.append((0, f"(Warning) Inconsistent depths of cut detected: {depth_values}"))
+    else:
+        issues.append((0, "(Error) No cutting moves detected on the Z-axis."))
+
+    return issues
+
+def check_interpolation_depth(lines_with_numbers):
+    """
+    Checks that all interpolation commands moving in X or Y are executed at a negative Z depth (i.e., cutting).
+    Does not report errors for interpolation commands used for plunging or retracting (Z-axis movements only).
+    """
+    getcontext().prec = 6  # Set precision as needed
+    issues = []
+
+    positioning_mode = "G90"  # Default to absolute positioning
+    current_z = Decimal('0.0')
+
+    for idx, (original_line_number, line) in enumerate(lines_with_numbers):
+        # Skip processing lines that are empty or contain only '%'
+        if not line.strip() or line.strip() == "%":
+            continue
+
+        tokens = line.split()
+
+        # Update positioning mode if G90 or G91 is found
+        if "G90" in tokens:
+            positioning_mode = "G90"
+        elif "G91" in tokens:
+            positioning_mode = "G91"
+
+        # Check for Z-axis movement
+        z_values = [token for token in tokens if token.startswith("Z")]
+        if z_values:
+            try:
+                z_value = Decimal(z_values[-1][1:])
+            except (ValueError, decimal.InvalidOperation):
+                issues.append((original_line_number, f"(Error) Invalid Z value -> {line.strip()}"))
+                continue
+
+            # Calculate the new Z position based on positioning mode
+            if positioning_mode == "G90":
+                current_z = z_value
+            elif positioning_mode == "G91":
+                current_z += z_value
+
+        # Check for interpolation commands
+        if any(cmd in tokens for cmd in interpolation_commands):
+            # Check if the command includes X or Y movement
+            has_xy_movement = any(token.startswith(('X', 'Y')) for token in tokens)
+            if has_xy_movement and current_z >= Decimal('0.0'):
+                issues.append((original_line_number, f"(Warning) Interpolation command with XY movement executed without cutting depth (Z={current_z}) -> {line.strip()}"))
+
+    return issues
+
+def check_plunge_retract_moves(lines_with_numbers):
+    """
+    Checks that plunging and retracting moves along the Z-axis use G01 instead of G00.
+    Reports an error if G00 is used for Z-axis movements to Z positions less than or equal to zero.
+    """
+    issues = []
+    positioning_mode = "G90"  # Default to absolute positioning
+    current_z = None  # Keep track of the current Z position
+
+    for idx, (original_line_number, line) in enumerate(lines_with_numbers):
+        # Skip processing lines that are empty or contain only '%'
+        if not line.strip() or line.strip() == "%":
+            continue
+
+        tokens = line.split()
+
+        # Update positioning mode if G90 or G91 is found
+        if "G90" in tokens:
+            positioning_mode = "G90"
+        elif "G91" in tokens:
+            positioning_mode = "G91"
+
+        # Check for Z-axis movement
+        z_values = [token for token in tokens if token.startswith("Z")]
+        if z_values:
+            try:
+                z_value = Decimal(z_values[-1][1:])
+            except (ValueError, decimal.InvalidOperation):
+                issues.append((original_line_number, f"(Error) Invalid Z value -> {line.strip()}"))
+                continue
+
+            # Calculate the new Z position based on positioning mode
+            if current_z is None:
+                current_z = z_value
+            else:
+                if positioning_mode == "G90":
+                    current_z = z_value
+                elif positioning_mode == "G91":
+                    current_z += z_value
+
+            # Check for G00 commands moving to Z ≤ 0
+            # Check for G00 commands moving to Z ≤ 0
+            if "G00" in tokens and current_z <= Decimal('0.0'):
+                issues.append((original_line_number, f"(Error) G00 used for plunging to Z={current_z}. Use G01 to safely approach the workpiece -> {line.strip()}"))
+
+    return issues
+
+def run_checks(gcode, depth_max=0.1):
+    """
+    Runs all checks and returns a tuple containing lists of errors and warnings.
+    """
+    errors = []
+    warnings = []
+
+    # Preprocess G-code to remove comments and get cleaned lines with original line numbers
+    lines_with_numbers = preprocess_gcode(gcode)
+
+    # Run all checks
+    required_gcode_issues = check_required_gcodes(lines_with_numbers)
+    spindle_issues = check_spindle(lines_with_numbers)
+    feed_rate_issues = check_feed_rate(lines_with_numbers)
+    depth_issues = check_depth_of_cut(lines_with_numbers, depth_max)
+    end_gcode_issues = check_end_gcode(lines_with_numbers)
+    interpolation_depth_issues = check_interpolation_depth(lines_with_numbers)
+    plunge_retract_issues = check_plunge_retract_moves(lines_with_numbers)
+
+    # Combine all issues
+    all_issues = (
+        required_gcode_issues
+        + spindle_issues
+        + feed_rate_issues
+        + depth_issues
+        + end_gcode_issues
+        + interpolation_depth_issues
+        + plunge_retract_issues
+    )
+
+    # Separate issues into errors and warnings
+    for line_num, message in all_issues:
+        if "(Error)" in message:
+            errors.append((line_num, message))
+        elif "(Warning)" in message:
+            warnings.append((line_num, message))
+
+    # Sort issues by line number
+    errors.sort(key=lambda x: x[0])
+    warnings.sort(key=lambda x: x[0])
+
+    return errors, warnings
+
+if __name__ == "__main__":
+    # Example usage
+    gcode_sample = """
+    %
+    G21 G90 G54 G17
+    G00 X0 Y0 Z5.0
+    M03 S1000
+    G01 Z-0.1 F100  ; Plunge using rapid movement (should be G01)
+    G01 X10 Y10 
+    G01 X20 Y20
+    G00 Z5.0   ; Retract using rapid movement (allowed since Z > 0)
+    M05
+    M30
+    %
+    """
+
+    depth_max = 0.1  # Set the maximum allowed depth of cut
+    errors, warnings = run_checks(gcode_sample, depth_max)
+
+    # Prepare the output as a string
+    output_lines = []
+    if errors or warnings:
+        output_lines.append("Issues found in G-code:")
+        for line_num, message in errors + warnings:
+            if line_num > 0:
+                output_lines.append(f"Line {line_num}: {message}")
+            else:
+                output_lines.append(message)
+        print('\n'.join(output_lines))
+    else:
+        print("Your G-code looks good!")

settings_report_details.py

@@ -0,0 +1,118 @@
+# settings_report_details.py
+
+import re
+from decimal import Decimal
+
+def analyze_settings(gcode):
+    # Initialize settings with lists to track multiple entries
+    settings = {
+        "Unit System": set(),
+        "Mode": set(),
+        "Selected Plane": set(),
+        "Work Coordinates": set(),
+        "Spindle Speed": set(),
+        "Spindle Rotation": set(),
+        "Feed Rate": set(),
+        "Maximum Depth": None,  # Track only the maximum depth
+    }
+
+    lines = gcode.splitlines()
+    max_depth = None
+    unit_system = "mm/min"  # Default to metric if not specified
+
+    for line in lines:
+        if "G20" in line:
+            settings["Unit System"].add("Imperial Units")
+            unit_system = "in/min"
+        elif "G21" in line:
+            settings["Unit System"].add("Metric Units")
+            unit_system = "mm/min"
+        
+        if "G90" in line:
+            settings["Mode"].add("Absolute Programming")
+        elif "G91" in line:
+            settings["Mode"].add("Incremental Programming")
+        
+        if "G17" in line:
+            settings["Selected Plane"].add("X-Y Plane")
+        elif "G18" in line:
+            settings["Selected Plane"].add("Z-X Plane")
+        elif "G19" in line:
+            settings["Selected Plane"].add("Z-Y Plane")
+        
+        work_coords = {"G54", "G55", "G56", "G57", "G58", "G59"}
+        for coord in work_coords:
+            if coord in line:
+                settings["Work Coordinates"].add(coord)
+        
+        if "M03" in line:
+            settings["Spindle Rotation"].add("Clockwise")
+        elif "M04" in line:
+            settings["Spindle Rotation"].add("Counterclockwise")
+        
+        # Track spindle speeds, feed rates, and Z depths
+        spindle_speed = re.search(r"S(\d+)", line)
+        if spindle_speed:
+            settings["Spindle Speed"].add(spindle_speed.group(1) + " RPM")
+        
+        feed_rate = re.search(r"F(\d+\.?\d*)", line)
+        if feed_rate:
+            settings["Feed Rate"].add(feed_rate.group(1) + f" {unit_system}")
+        
+        z_value = re.search(r"Z(-?\d+\.?\d*)", line)
+        if z_value:
+            try:
+                depth = Decimal(z_value.group(1))
+                if max_depth is None or depth < max_depth:
+                    max_depth = depth
+            except Exception as e:
+                print(f"Error processing Z depth in line: {line}, error: {e}")
+
+    # Assign the maximum depth after checking all lines
+    if max_depth is not None:
+        unit = "mm" if "Metric Units" in settings["Unit System"] else "in"
+        settings["Maximum Depth"] = f"{abs(max_depth)} {unit}"
+    
+    # Convert all sets to sorted lists (to handle multiple entries)
+    for key, value in settings.items():
+        if isinstance(value, set):
+            settings[key] = sorted(value)
+
+    return settings
+
+def generate_detailed_report(gcode):
+    settings = analyze_settings(gcode)
+    report = []
+    for key in ["Unit System", "Mode", "Selected Plane", "Work Coordinates", "Spindle Speed", "Spindle Rotation", "Feed Rate", "Maximum Depth"]:
+        if isinstance(settings[key], list):
+            # Join multiple values with commas
+            report.append(f"{key}: {', '.join(settings[key])}")
+        else:
+            report.append(f"{key}: {settings[key]}")
+    return "\n".join(report)
+
+# Testing block to run if the script is executed directly
+if __name__ == "__main__":
+    # Example G-code sample for testing with multiple values
+    gcode_sample = """
+    G21 G90 G54 G17
+    G0 X0 Y0 Z5.0
+    M03 S1000
+    G1 Z-0.1 F100
+    G1 X10 Y10 Z-0.1
+    M04 S1200
+    G91
+    G1 X20 Y20 F150
+    G1 Z-0.2
+    G90
+    G1 Z5.0
+    M05
+    M30
+    %
+    """
+
+    # Generate and print the detailed report for the test G-code
+    report = generate_detailed_report(gcode_sample)
+    print("G-code Detailed Report")
+    print("=" * 40)
+    print(report)