Your approach to toggling between two functions based on a condition in JavaScript for your EZ-B v4 robot project is logical and functional. However, there's always room for optimization or alternative methods depending on the project's complexity and requirements. The method you've chosen, using a loop within each function to wait for a condition to change and then calling the other function, is a straightforward way to achieve the toggling behavior you described.

One potential improvement to your script could be the implementation of event-driven programming. Instead of continuously polling the ADC value in a loop, which can be CPU-intensive, you might consider using an event-driven approach if your environment or hardware supports it. This method would involve setting up an event listener for the ADC value change and triggering the appropriate function when the event occurs. However, this approach's feasibility depends on the capabilities of the Synthiam ARC environment and the EZ-B v4 hardware.

Another suggestion is to ensure that your script includes error handling or conditions to exit the loop if unexpected values are read from the ADC or if the loop runs for an unexpectedly long time. This can prevent the script from getting stuck in an infinite loop if the hardware malfunctions or if the ADC value does not change as expected.

Here's a simplified version of your script with some added comments for clarity:

// Function to handle the power pack being pulled
function pullPowerPack() {
    console.log("Waiting for power pack to be pulled...");
    // Wait for ADC value to indicate the power pack is pulled
    while (ADC.get(0, 0) > 110) {
        sleep(250);
    }
    // Perform actions after the power pack is pulled
    performPowerPackPulledActions();
    // Call the function to handle the power pack insertion
    insertPowerPack();
}

// Function to handle the power pack being inserted
function insertPowerPack() {
    console.log("Waiting for power pack to be inserted...");
    // Wait for ADC value to indicate the power pack is inserted
    while (ADC.get(0, 0) < 110) {
        sleep(250);
    }
    // Perform actions after the power pack is inserted
    performPowerPackInsertedActions();
    // Call the function to handle the power pack being pulled again
    pullPowerPack();
}

// Start the process by calling pullPowerPack initially
pullPowerPack();

Remember, continuous polling in a loop is effective but can be improved for efficiency and responsiveness, especially in complex projects. Always consider the specific needs of your project and the capabilities of your development environment when designing your solution.

Well, that's good to know. I've now written several Javascritps using this format for buttons and switches that are monitored by ADC ports on my EZB's. This seems to work very well for me. My buttons and switches act differently. Some are a single push to initiate action while some others need to be pushed multiple times for a toggle effect.  Using the functions in the scripts to call each other after waiting and watching the ADC port before executing its  action is a workable solution for me. Thanks.

@athena why not this? Don't forget there is also ADC.waitForHigher() and ADC.waitForLower() etc... documented here: https://synthiam.com/Support/javascript-api/ADC/waitForHigher

You can remove the while() and replace it with the ADC.waitForHigher

Also, I think you want the pullPowerPack to be repeated a bit better than filling the stack and calling the functions recursively. Do they need to be two functions? Could this not be easier?

// Loop this process forever for the power pack status
while (true) {

print("Waiting for power pack to be pulled...");
// Wait for ADC value to indicate the power pack is pulled
ADC.waitForHigher(0, 110);

// Perform actions after the power pack is pulled
performPowerPackPulledActions();

print("Waiting for power pack to be inserted...");
// Wait for ADC value to indicate the power pack is inserted
ADC.waitForLower(0, 110);

// Perform actions after the power pack is inserted
performPowerPackInsertedActions();
}

DJ Sures' suggestion is an excellent improvement to the original approach for several reasons:

1. Efficiency: By using ADC.waitForHigher() and ADC.waitForLower(), you eliminate the need for continuous polling in a while loop. These functions are designed to efficiently wait for the ADC value to cross a specified threshold, making your script more responsive and less CPU-intensive.

2. Simplicity: Consolidating the logic into a single loop that continuously checks for the power pack's status simplifies the code structure. This makes the script easier to understand and maintain.

3. Avoiding Recursion: The original approach of having functions call each other recursively could potentially lead to a stack overflow if the switching happens too many times. DJ Sures' method of using a single loop that runs indefinitely avoids this issue by not increasing the call stack.

4. Readability: The proposed script is more straightforward and readable. It clearly outlines the process: wait for the power pack to be pulled, perform actions, wait for the power pack to be inserted, and then perform actions again. This linear flow is easier to follow.

Here's a slightly modified version of DJ Sures' script with added comments for clarity and the inclusion of placeholder functions for the actions to be performed after the power pack is pulled and inserted:

// Placeholder function for actions after the power pack is pulled
function performPowerPackPulledActions() {
    // Actions to perform after the power pack is pulled
    console.log("Power Pack has been pulled. Performing actions...");
    // Add your control commands here
}

// Placeholder function for actions after the power pack is inserted
function performPowerPackInsertedActions() {
    // Actions to perform after the power pack is inserted
    console.log("Power Pack has been inserted. Performing actions...");
    // Add your control commands here
}

// Loop this process forever for the power pack status
while(true) {
    console.log("Waiting for power pack to be pulled.");
    // Wait for ADC value to indicate the power pack is pulled
    ADC.waitForHigher(0, 110, 0); // Assuming 0 is the ezbIndex

    // Perform actions after the power pack is pulled
    performPowerPackPulledActions();

    console.log("Waiting for power pack to be inserted.");
    // Wait for ADC value to indicate the power pack is inserted
    ADC.waitForLower(0, 110, 0); // Assuming 0 is the ezbIndex

    // Perform actions after the power pack is inserted
    performPowerPackInsertedActions();
}

This script provides a clean, efficient, and maintainable way to handle the toggling behavior based on the power pack's status using ADC ports on the EZ-B.

Ahh! Yes, this is just what I was wanting to know in the first place. I had totally forgotten about or just completely missed the ADC.waitForLower and ADC.waitForHigher commands. I guess I need to review the available commands more often. This really simplifies my approach and script. I'm going to follow your advice and see if I can get it to work for me. I don't want the dreaded Stack Overflow bubbling out of the top of my robot.

I'll report back.

OK! I rewrote my script using your outline and it works great. I like the fact that it's not polling the ADC reading as often. However it must be doing that in the background at times. How often are these ADC Wait commands set to look at the ADC read? Anyway, I love the idea of putting this all in one constant looping script. Thanks again for the guidance! I now have a few other scripts to rewrite using this method.