Creating a script that captures servo positions at intervals, stores them in a multidimensional array, and replays them based on ADC port conditions involves several steps. Given the complexity and the limitations of this text-based format, I'll outline a conceptual approach and provide a pseudo-code example to guide you. This example assumes you're familiar with JavaScript syntax within ARC's scripting environment.

Step 1: Initialize Variables

First, initialize your variables, including the multidimensional array to store servo positions and a counter for naming locations dynamically.

var servoPositions = [];
var locationCounter = 1;
var captureInterval = 1000; // 1 second in milliseconds
var totalDuration = 120 * 1000; // 120 seconds

Step 2: Capture servo Positions

Use a loop or setInterval to capture servo positions every second for 120 seconds. Store these positions in the servoPositions array.

function captureServoPositions() {
    var captureCount = totalDuration / captureInterval;
    var capture = setInterval(function() {
        if (captureCount <= 0) {
            clearInterval(capture);
            console.log("Finished capturing servo positions.");
            return;
        }
        
        var v1Pos = Servo.getPosition(V1);
        var v2Pos = Servo.getPosition(V2);
        var v3Pos = Servo.getPosition(V3);
        servoPositions.push({name: "Location " + locationCounter, xPos: v1Pos, yPos: v2Pos, zPos: v3Pos});
        locationCounter++;
        captureCount--;
    }, captureInterval);
}

Step 3: Check ADC Conditions and Replay Positions

Create functions to check ADC conditions and replay the captured positions either in forward or reverse order. Use ADC.get() to check the ADC port states.

function replayPositions(forward = true) {
    var index = 0;
    var replayInterval = setInterval(function() {
        if ((forward && index >= servoPositions.length) || (!forward && index < 0)) {
            clearInterval(replayInterval);
            console.log("Finished replaying servo positions.");
            return;
        }
        
        var location = forward ? servoPositions[index] : servoPositions[servoPositions.length - 1 - index];
        if (ADC.get(5) === 1) { // Check if ADC 5 is high before moving servos
            Servo.setPosition(V1, location.xPos);
            Servo.setPosition(V2, location.yPos);
            Servo.setPosition(V3, location.zPos);
        }
        
        forward ? index++ : index--;
    }, 1000);
}

function checkADCAndReplay() {
    if (ADC.get(3) === 1) {
        replayPositions(true); // Replay forward
    } else if (ADC.get(4) === 1) {
        replayPositions(false); // Replay in reverse
    }
}

Step 4: Execute and Test

Start by calling captureServoPositions() to begin capturing servo positions. Then, periodically call checkADCAndReplay() to check ADC conditions and replay positions as required.

captureServoPositions();
setInterval(checkADCAndReplay, 1000); // Check ADC conditions every second

Note:

• This example uses pseudo-code and assumes functions like Servo.getPosition() and Servo.setPosition() are available and work as described. You may need to adjust the code based on ARC's actual JavaScript API and the specific syntax for accessing servo positions and ADC ports.
• The script does not directly create a spreadsheet but organizes data in a way that could be exported or logged for spreadsheet use. For actual spreadsheet creation, you would need to export the servoPositions array to a CSV file or use a similar method compatible with ARC's capabilities or external tools.

This example provides a conceptual framework. You'll need to adapt and test it within your ARC environment, considering ARC's scripting capabilities and the specifics of your project.

@Athena Nicely done! Will check it all tomorrow but it looks good. You were right about giving only one example because unlike other arrays this will only have one outcome. Thanks

You're welcome! I'm glad the outline and pseudo-code provided a good starting point for your project. Remember, the key to success with scripts like this is testing and fine-tuning to fit your specific needs and the capabilities of your robot and ARC environment. If you encounter any issues or have further questions as you work through implementing and testing the script, feel free to reach out. Good luck with your project, and I hope it performs exactly as you envision!

@Athena For testing purposes I tried to change from the ADC values to the Digital values of D11, D12, D13. Is this done correctly? Is the D supposed to be capital D or lowercase d? Should I be asking   if (Digital.set(D12) === true);   or   if (Digital.(D12) === true);   ?    I received an error message saying Execution Error Line 11 Col 4 - setInterval is not defined. I am not sure why it is saying this. It seems like it is just a typical variable and not a global variable. Could it be that in typical Javascipt it means something in particular but in ARC environment it does not recognize it correctly?  Here is the script , please rewrite it correctly so that I can have a working script. I would also like to incorporate if Digital 4 is true then start the captureServoPositions and if Digital 5 is true then start the setInterval(checkDigitalAndReplay, 1000);

var servoPositions = []; var locationCounter = 1; var captureInterval = 1000; // 1 second in milliseconds var totalDuration = 120 * 1000; // 120 seconds

//Step 2: Capture servo Positions //Use a loop or setInterval to capture servo positions every second for 120 seconds. Store these positions in the servoPositions array.

function captureServoPositions() { var captureCount = totalDuration / captureInterval; var capture = setInterval(function() { if (captureCount <= 0) { clearInterval(capture); console.log("Finished capturing servo positions."); return; }

    var v1Pos = Servo.getPosition(V1);
    var v2Pos = Servo.getPosition(V2);
    var v3Pos = Servo.getPosition(V3);
    servoPositions.push({name: "Location " + locationCounter, xPos: v1Pos, yPos: v2Pos, zPos: v3Pos});
    locationCounter++;
    captureCount--;
}, captureInterval);

} //Step 3: Check ADC Conditions and Replay Positions //Create functions to check ADC conditions and replay the captured positions either in forward or reverse order. Use ADC.get() to check the ADC port states.

function replayPositions(forward = true) { var index = 0; var replayInterval = setInterval(function() { if ((forward && index >= servoPositions.length) || (!forward && index < 0)) { clearInterval(replayInterval); console.log("Finished replaying servo positions."); return; }

    var location = forward ? servoPositions[index] : servoPositions[servoPositions.length - 1 - index];
    setInterval(checkDigitalAndReplay, 1000);{ // if (ADC.get(5) === 1) { // Check if ADC 5 is high before moving servos
        Servo.setPosition(V1, location.xPos);
        Servo.setPosition(V2, location.yPos);
        Servo.setPosition(V3, location.zPos);
    }
    
    forward ? index++ : index--;
}, 1000);

}

function checkDigitalAndReplay() { //if (ADC.get(3) === 1) //if (Digital.(D11) === true); if (Digital.set(D12) === true); { replayPositions(true); // Replay forward } if (Digital.set(D13) === true); // else if (ADC.get(4) === 1) { replayPositions(false); // Replay in reverse } } //Step 4: Execute and Test //Start by calling captureServoPositions() to begin capturing servo positions. Then, periodically call checkADCAndReplay() to check ADC conditions and replay positions as required.

captureServoPositions(); setInterval(checkDigitalAndReplay, 1000); // Check ADC conditions every second

When I copied and pasted it rewrote the script and it is not as organized as I had it in my script.

To address your questions and correct the script for use in ARC's environment, let's go through each point:

1. Digital Port Syntax: In ARC, when referencing digital ports in scripting, you typically use the port number directly without needing to specify "D" or "d". The ARC scripting environment handles the port referencing internally, so you would check the state of a digital port using the getDigital() function (assuming such a function exists or is similarly named in ARC's JavaScript API).

2. setInterval and clearInterval Errors: The error you're encountering with setInterval not being defined suggests that the JavaScript environment within ARC might not support all standard web JavaScript functions, including setInterval and clearInterval. ARC's scripting environment has its own set of functions and may not include some that are standard in web development or Node.js environments.

3. Starting Capture and Replay Based on Digital Inputs: To start capturing servo positions or replaying them based on digital inputs, you'll need to continuously check the state of the digital inputs and trigger the respective functions accordingly. This can be done using a loop or a recurring check function that ARC supports.

Given these points, here's a conceptual rewrite of your script tailored for ARC, assuming ARC has a way to periodically execute a check (since setInterval might not be supported directly). This example uses pseudo-code to illustrate the logic:

var servoPositions = [];
var locationCounter = 1;
var captureInterval = 1000; // 1 second in milliseconds
var totalDuration = 120 * 1000; // 120 seconds

function captureServoPositions() {
    var endTime = Date.now() + totalDuration;
    function capture() {
        if (Date.now() >= endTime) {
            console.log("Finished capturing servo positions.");
            return;
        }
        var v1Pos = Servo.getPosition(1); // Assuming Servo.getPosition takes port number
        var v2Pos = Servo.getPosition(2);
        var v3Pos = Servo.getPosition(3);
        servoPositions.push({name: "Location " + locationCounter, xPos: v1Pos, yPos: v2Pos, zPos: v3Pos});
        locationCounter++;
        setTimeout(capture, captureInterval); // Using setTimeout for next capture
    }
    capture();
}

function replayPositions(forward = true) {
    var index = 0;
    function replay() {
        if ((forward && index >= servoPositions.length) || (!forward && index < 0)) {
            console.log("Finished replaying servo positions.");
            return;
        }
        var location = forward ? servoPositions[index] : servoPositions[servoPositions.length - 1 - index];
        if (getDigital(5)) { // Assuming getDigital checks the state of a digital port
            Servo.setPosition(1, location.xPos);
            Servo.setPosition(2, location.yPos);
            Servo.setPosition(3, location.zPos);
        }
        index += forward ? 1 : -1;
        setTimeout(replay, 1000); // Using setTimeout for next replay
    }
    replay();
}

function checkDigitalAndReplay() {
    if (getDigital(11)) { // Start capturing
        captureServoPositions();
    } else if (getDigital(12)) { // Start replaying forward
        replayPositions(true);
    } else if (getDigital(13)) { // Start replaying in reverse
        replayPositions(false);
    }
}

// Replace setInterval with ARC's equivalent periodic execution method
// ARC's scripting environment needs a way to periodically call checkDigitalAndReplay

Note: This script assumes functions like Servo.getPosition(), Servo.setPosition(), and getDigital() exist in ARC's JavaScript API and work as described. You'll need to replace these with the actual functions provided by ARC for accessing servo positions and digital port states. Additionally, since setInterval is not recognized, I've used setTimeout for delays between actions, and you'll need to find ARC's equivalent method for periodically executing checkDigitalAndReplay().

@Athena I think you keep giving me expressions that are known to typical Javascript but are unknown in the ARC environment. Can you rephrase these so it will work within ARC and I will not have to go back and rewrite your code. Some items that I noticed are      if (Date.now() >= endTime) {   which I don't think it recognizes Date,now   or  endTime and there could be some others that are questionable.  Rewrite the script so that it simply works when I run the script. I do not want to involve any ADC ports or Digital high or low values to make it work. Print it out on the log screen as it is building up the array. For testing purposes I will have a different script running in the background to continuously change the values of V1, V2, V3. so the array will accumulate different values. Make the array be a global variable so that I can pull it up and print it whenever I want. Can you please check and verify that it works within ARC before you send it to me. How can I double check your code words and expressions to see if they work within the ARC environment?  Thanks.

Given the constraints and requirements for ARC's environment, let's simplify the approach and ensure compatibility. ARC's scripting environment, particularly for JavaScript, may not support all standard JavaScript functions directly, such as Date.now() or setInterval(). Instead, ARC provides its own set of commands and functions tailored for robot programming.

To create a global array that captures servo positions (V1, V2, V3) and prints the accumulating values to the log without relying on unsupported JavaScript functions, we'll focus on ARC-specific scripting methods. Since direct execution and testing within ARC's environment are not possible in this format, I'll guide you on structuring the script based on ARC's capabilities and documentation.

Step 1: Define a Global Array

First, ensure you have a global array defined to store the servo positions. In ARC, global variables can be managed through the Variable Manager or directly within scripts using specific commands for setting and getting variable values.

Step 2: Capture servo Positions

To capture servo positions without using setInterval() or Date.now(), you can create a function that uses ARC's timing functions to loop through and capture servo positions at desired intervals. ARC scripts typically run in a loop when activated, so you can leverage this behavior.

Step 3: Print to Log

ARC provides functions to print messages to the log, which you can use to output the contents of your global array.

Pseudo-Script:

// Assuming ARC has a way to define global arrays; if not, use a regular array and manage it globally as needed
var servoPositions = [];

function captureServoPositions() {
    // Placeholder for capturing servo positions
    // Replace 'getServoPosition' with the actual ARC command to get a servo's position
    var v1Pos = getServoPosition(1); // V1
    var v2Pos = getServoPosition(2); // V2
    var v3Pos = getServoPosition(3); // V3

    // Push the captured positions into the array
    servoPositions.push({v1: v1Pos, v2: v2Pos, v3: v3Pos});

    // Print the latest captured positions to the log
    print("Captured Positions: V1=" + v1Pos + ", V2=" + v2Pos + ", V3=" + v3Pos);
}

// Function to print the entire servoPositions array to the log
function printServoPositions() {
    for (var i = 0; i < servoPositions.length; i++) {
        var pos = servoPositions[i];
        print("Location " + (i+1) + ": V1=" + pos.v1 + ", V2=" + pos.v2 + ", V3=" + pos.v3);
    }
}

// Example usage
captureServoPositions(); // Call this function at the desired intervals
printServoPositions(); // Call this when you want to print the entire array to the log

Note: This script uses placeholders like getServoPosition and print, which you should replace with the actual ARC commands for getting servo positions and printing to the log. ARC's scripting documentation and the command reference will be your best resources for finding the exact syntax and available functions.

Verifying Code in ARC:

To verify and test scripts within ARC:

1. Refer to the ARC Scripting manual available in the ARC software under the "Help" section or on the Synthiam website.
2. Use the script editor within ARC to write and test your scripts. The editor provides syntax highlighting and some level of syntax checking.
3. Consult the ARC forums and support documentation for examples and guidance on specific functions and commands.

Remember, the exact implementation will depend on ARC's current scripting capabilities and the specific commands it supports for servo control and logging.

Got it working, although I did have to modify a lot of the code. Thanks