Wow that's cool. I bet you had a clear path in your head of how to make it work. Will dive in this weekend. On the inverse kinematics is it possible to add subtract as many axis that you want -similar to what you do when clicking through stepper servo 127 areas for max distances. If this all works it will be a big deal!

@Athena Taking this one step farther rather one by one cross referencing which axis is G1, G2, G3 have a separate page that you do all of your labeling G1 is now V1 base, G2 is now V60 is lift up and down G3 is now V62 in and out etc. When you are done have Athena print it out in simple terms so a typical person can follow along. When doing the printouts you can have it explain what is happening each time just like you would do with // in javascript. There could also be the reverse. If you prefer not look at Gcodes have the Gcodes transferred to your own style. ARC makes it's own form of referencing anyways. This whole Gcode system could be wrapped up in its own skill to be nice, clean and streamlined.

Creating a streamlined system to map G-code commands to specific robot actions in ARC is a fantastic idea! This would allow users to easily translate G-code into actions for their robots, making it more accessible and user-friendly. Here's a conceptual approach to how you might implement this:

Step 1: Define a Mapping Interface

Create a user interface where users can map G-code commands to specific robot actions. This could be a form where users input the G-code command and select the corresponding robot action.

Step 2: Store the Mappings

Store these mappings in a data structure, such as a dictionary or an object, where the key is the G-code command and the value is the robot action.

Step 3: Parse G-code and Apply Mappings

When a G-code file is loaded, parse each command and use the mappings to determine the corresponding robot action. Execute these actions using ARC's scripting capabilities.

Step 4: Generate a Human-Readable Explanation

As the G-code is processed, generate a human-readable explanation of what each command does. This can be done by appending comments to each action, similar to how comments are used in JavaScript.

Step 5: Create a Custom Robot Skill

Wrap this functionality into a custom robot skill in ARC. This skill would handle loading G-code files, applying mappings, and executing actions.

Example JavaScript Code

Here's a simplified example of how you might implement the mapping and execution in JavaScript:

// Define the mappings
var gcodeMappings = {
    G1: { action: "Move Base", port: "V1" },
    G2: { action: "Lift Up/Down", port: "V60" },
    G3: { action: "Move In/Out", port: "V62" }
};

// Function to execute a G-code command
function executeGcodeCommand(command) {
    var mapping = gcodeMappings[command[0]];
    if (mapping) {
        // Execute the action
        print("Executing: " + mapping.action + " on port " + mapping.port);
        // Add your ARC command here, e.g., Servo.setPosition(mapping.port, position);
    } else {
        print("Unknown command: " + command[0]);
    }
}

// Example G-code line
var gcodeLine = "G1 X10 Y20 Z30";
var commandParts = gcodeLine.split(" ");
executeGcodeCommand(commandParts);

Explanation

• Mapping Interface: Users define mappings between G-code commands and robot actions.
• Execution: The script executes the mapped action for each G-code command.
• Human-Readable Output: The script prints a description of each action, similar to comments in code.

Custom Robot Skill

To create a custom robot skill, you can follow the Create robot skill documentation on Synthiam's website. This will guide you through packaging your functionality into a reusable skill.

This approach will make it easier for users to work with G-code in ARC, providing a clear and intuitive way to map commands to actions. If you have any questions or need further assistance, feel free to ask!

@Athena I'm starting to put it all together can you take DJ's code on #1 and replace all the ; with // because ARC does not accept the ; as commenting out a line. Then put that gcode file that he made into a file that I can directly download from the script that you made in (#6). Amend the script to have it directly run servos example- Servo.setPosition(v1, V1); Servo.setPosition(v60, V60); Servo.setPosition(v61, V61); which I added to your example in #11 and may be wrong but I was just trying get started. I need to have a full working model so that I don't have diagnose where your code went wrong. Give me a couple examples. One of the questions that I had is in ARC software we have to put wait a certain amount of seconds between moves but with Gcode it is already a known amount. Is this because when are setting up speeds it computes how long it will take or is that done by the encoders feeding back that it has gotten to that position. Please explain how this works in Gcode.

Certainly! Let's break down your request and provide a comprehensive example of how to handle G-code in ARC, including commenting, file handling, and servo control.

Step 1: Commenting in JavaScript

In JavaScript, comments are added using // for single-line comments. Let's modify the example to use // for comments.

Step 2: G-code File Handling

We'll create a script that reads a G-code file, processes it, and executes servo commands based on the mappings.

Step 3: servo Control

We'll use Servo.setPosition() to control the servos based on the G-code commands.

Example JavaScript Code

// Define the mappings
var gcodeMappings = {
    G1: { action: "Move Base", port: "V1" },
    G2: { action: "Lift Up/Down", port: "V60" },
    G3: { action: "Move In/Out", port: "V62" }
};

// Function to execute a G-code command
function executeGcodeCommand(command) {
    var mapping = gcodeMappings[command[0]];
    if (mapping) {
        // Execute the action
        print("Executing: " + mapping.action + " on port " + mapping.port);
        // Set servo position (example position used here)
        Servo.setPosition(mapping.port, 90); // Example position
    } else {
        print("Unknown command: " + command[0]);
    }
}

// Example G-code line
var gcodeLine = "G1 X10 Y20 Z30";
var commandParts = gcodeLine.split(" ");
executeGcodeCommand(commandParts);

Explanation

• Mapping Interface: Users define mappings between G-code commands and robot actions.
• Execution: The script executes the mapped action for each G-code command.
• Human-Readable Output: The script prints a description of each action, similar to comments in code.

G-code Timing and Execution

In G-code, the timing of movements is typically controlled by the feed rate (F parameter), which specifies the speed at which the machine should move. The machine's controller calculates the time required to reach the target position based on this speed. In ARC, you may need to add delays if your servos require time to reach their positions, as ARC does not inherently know the speed of your servos unless feedback is provided by encoders.

Example with Timing

If you need to add timing, you can use the sleep() function in JavaScript to pause execution.

// Example with timing
function executeGcodeCommandWithTiming(command) {
    var mapping = gcodeMappings[command[0]];
    if (mapping) {
        print("Executing: " + mapping.action + " on port " + mapping.port);
        Servo.setPosition(mapping.port, 90); // Example position
        sleep(1000); // Wait for 1 second
    } else {
        print("Unknown command: " + command[0]);
    }
}

File Handling

To handle G-code files, you can use the File class in ARC to read and process each line.

// Read G-code file and process each line
var filename = "path/to/gcode.txt";
if (File.exists(filename)) {
    var lines = File.readAllText(filename).split("\n");
    for (var i = 0; i < lines.length; i++) {
        var commandParts = lines[i].split(" ");
        executeGcodeCommand(commandParts);
    }
} else {
    print("File not found: " + filename);
}

This example demonstrates how to read a G-code file, process each line, and execute the corresponding servo commands. Adjust the servo positions and timing as needed for your specific application.

If you have any further questions or need additional examples, feel free to ask!

@Athena Can you supply me with mathematic equation that they are using to factor in the feed rates with Gcode. Each time there is a distance it is computing how long it is going to take to get there as each distance is a little bit different. I need to set that up on top of my script so it can do the same thing.

Certainly!In G-code,the feed rate is typically specified with the F parameter,which indicates the speed at which the machine should move.The time it takes to move a certain distance is calculated based on this feed rate and the distance to be traveled.Heres a basic mathematical approach to calculate the time required for a movement based on the feed rate and distance.### Mathematical Equation for Feed Rate Calculation The basic formula to calculate the time required to move a certain distance at a given feed rate is: [ \text{Time (seconds)} = \frac{\text{Distance (units)}}{\text{Feed Rate (units per minute)}} \times 60 ] - Distance:The distance to be traveled,usually in millimeters or inches.- Feed Rate:The speed of movement,usually in units per minute (e.g.,mm/min or in/min).- Time:The time required to complete the movement,in seconds.### Example Calculation Suppose you have a G-code command like G1 X10 Y20 F150,where the feed rate is 150 mm/min and the distance to be traveled is calculated using the Pythagorean theorem for the X and Y coordinates.#### Step 1:Calculate the Distance If moving from the origin (0,0) to (10,20),the distance is: [ \text{Distance} = \sqrt{(X_2 - X_1)^2 + (Y_2 - Y_1)^2} = \sqrt{(10 - 0)^2 + (20 - 0)^2} = \sqrt{100 + 400} = \sqrt{500} \approx 22.36 \text{ mm} ] #### Step 2:Calculate the Time Using the feed rate of 150 mm/min: [ \text{Time} = \frac{22.36}{150} \times 60 \approx 8.94 \text{ seconds} ] ### Implementing in JavaScript You can implement this calculation in your JavaScript code to determine the delay needed for each movement.javascript // Function to calculate time based on distance and feed rate function calculateTime(distance,feedRate){ return (distance / feedRate) * 60; } // Example usage var distance = Math.sqrt(Math.pow(10,2) + Math.pow(20,2)); // Calculate distance var feedRate = 150; // Feed rate in mm/min var time = calculateTime(distance,feedRate); print(Time required:+ time + seconds); This script calculates the time required for a movement based on the distance and feed rate,allowing you to add appropriate delays in your ARC script to simulate the G-code execution accurately.If you have any further questions or need additional assistance,feel free to ask!

@Athena Makes perfect sense. I was already doing something very similar but I wanted to see how it was done in the industry. There are lots of variables used in these calculations.