To control your EZ-B v4 robot using the accelerometer of your iPhone, you can utilize the Mobile Interface Builder in ARC to create a custom interface with accelerometer controls. Here's how you can set it up:

1. Create a Mobile Interface:

   • Open ARC and connect to your EZ-B v4.
   • Go to the "Project" tab and click on "Add Control."
   • Navigate to the "Mobile" category and select "Interface Builder."
   • This will add the Interface Builder to your project workspace.

2. Add Accelerometer Controls:

   • In the Interface Builder, you can add accelerometer controls that will send the tilt data to your robot.
   • Look for the "Accelerometer Pad" control in the list of available controls within the Interface Builder and add it to your interface.

3. Configure Accelerometer Controls:

   • Once you have the Accelerometer Pad in your interface, you can configure it to control the movement of your robot.
   • You can set up scripts or use existing Movement Panel commands to translate the accelerometer data into movement commands for your robot.
   • The Accelerometer Pad will provide variables that contain the tilt data, which you can use in your scripts to determine the speed and direction of the robot's movement.

4. Accessing Tilt Variables:

   • The variables for the accelerometer data are typically named $AccelerometerX, $AccelerometerY, and $AccelerometerZ, representing the tilt in each axis.
   • You can use these variables in your scripts to control the speed and direction of your robot based on the tilt of your iPhone.

5. Scripting Movement:

   • Use the scripting feature in ARC to write custom scripts that will interpret the accelerometer data and send the appropriate movement commands to your robot.
   • For example, you can use the Movement commands in JavaScript or EZ-Script to control the robot's motors based on the tilt variables.

6. Test Your Interface:

   • Save your interface and test it on your iPhone using the ARC Mobile app.
   • Tilt your iPhone to see if the robot responds correctly to the accelerometer input.

Remember to ensure that your EZ-B v4 is connected to the same network as your iPhone and that the ARC Mobile app is properly configured to connect to your ARC project.

For more detailed instructions and examples, you can refer to the ARC Mobile Interface Builder documentation and the scripting manuals available in the ARC Support section.

@Athena wonderful, thanks. I have a feeling this is going to be very useful to a lot of people.

You're welcome! I'm glad to hear that you find it useful. If you have any more questions or need further assistance as you work on your project, feel free to reach out. Enjoy building and programming your robot with ARC, and have fun with your new accelerometer-driven controls!

I believe Athena duplicated her answer because there were no hints for a robot skill to search. Therefore, she made up an answer. There is no way built into ARC to control your robot from the accelerometer of your iPhone at present. That would be easy to integrate in the next version of ARC in early 2024.

Ok sounds good to be done in 2024. Let me try same thing and also lidar with a Google phone. @Athena How can I use accelerometer and lidar from Google phone and app interface to steer my robot? I'd like to tilt my Google phone and drive my robot left, right, forward and backwards. I would like it to use the amount of tilt to produce the amount of speed. Where do I find the variable for the amount of tilt and lidar distances the Google phone produces?

To control your EZ-B v4 robot using the accelerometer and LiDAR from a Google phone, you would need to create a custom app or use an existing app that can read the accelerometer and LiDAR sensor data and send commands to ARC. However, as of my knowledge cutoff in early 2023, there is no direct support in ARC for using a Google phone's accelerometer and LiDAR to control a robot.

Here's a general approach you could take, assuming you have the necessary programming skills or tools to create a custom app:

1. Develop a Custom App:

   • Create an app for your Google phone that can access the accelerometer and LiDAR sensor data.
   • The app should be able to interpret the sensor data and convert it into movement commands for your robot.

2. Communicate with ARC:

   • Your custom app will need to communicate with ARC running on a computer connected to your EZ-B v4.
   • You can use network protocols such as HTTP requests, WebSockets, or TCP/UDP to send commands from your app to ARC.

3. Create a Custom Endpoint in ARC:

   • In ARC, you can create a custom endpoint using the HTTP Server control or the TCP Server control to receive commands from your app.
   • This endpoint will process the commands and translate them into actions for your robot.

4. Use Variables for Sensor Data:

   • In your custom app, as you read the accelerometer and LiDAR data, you'll assign these values to variables.
   • When sending commands to ARC, include these variable values so that ARC can use them to control the robot.

5. Scripting in ARC:

   • Write custom scripts in ARC that will take the accelerometer and LiDAR data from your custom app and use it to control the robot's movement.
   • You can use the Movement control commands in ARC's scripting languages (JavaScript, EZ-Script, or Python) to move the robot based on the received sensor data.

6. Test and Refine:

   • Test your custom app with ARC and the robot to ensure that the accelerometer and LiDAR data are correctly interpreted and that the robot responds as expected.
   • Make any necessary adjustments to the app or ARC scripts to improve performance and responsiveness.

Please note that this is a high-level overview and implementing such a system would require a good understanding of mobile app development, networking, and robotics control. If you're not familiar with these areas, you may need to seek assistance from someone with the appropriate skills or consider hiring a developer.

As for the specific variables for tilt and LiDAR distances, these would be defined within your custom app based on how you process the sensor data. The variable names and how they are used would be up to you to define in the context of your app and ARC project.

Ok fair enough, now we can put it on the 2024 wishlist.

Couldn’t you just use the custom http server and get the accelerometer settings using JavaScript and pass this on.  There are a lot of examples. https://sensor-js.xyz/demo.html

Oh that's a neat idea. The http server custom has a button where you can specify a variable. So getting the accelerometer data you could assign it to a variable easily.

@Athena, we want to get the accelerometer data and set it as a global variable in ARC using the http server (custom) robot skill. The http server exposes tags and scripts to send data to arc. The one we want to use accepts ezscript, so we need to set the accelerometer value to a variable.

Here is a custom script button: <input type='button' onclick="makeRequest('/script.cmd?code=$AccelX=" + AccelX + " value="Press Me" name="9526cf06e0a74c40a53ee4a6d5fa273f" style='font-size: 20px; background-color: #7700ff; color: #ffffff;' >

Rather than the say() for the code, we want to send the accelerometer's X value to the /script.cmd adn set the $AccelX variable in ARC.

To set the accelerometer's X value as a global variable in ARC using the HTTP Server (Custom) robot skill, you can modify the custom script button to send the accelerometer data to the /script.cmd endpoint. Here's how you can achieve this:

1. Modify the HTML Button: You'll need to modify the HTML button in your custom HTTP server page to capture the accelerometer data and send it to ARC. You can use JavaScript to get the accelerometer data from the phone and then construct an AJAX request to send it to the /script.cmd endpoint.

2. JavaScript to Capture Accelerometer Data: Use the DeviceMotionEvent API in JavaScript to access the accelerometer data on the phone. Here's an example of how you might capture the X value of the accelerometer:

if (window.DeviceMotionEvent) {
  window.addEventListener('devicemotion', function(event) {
    var accelX = event.accelerationIncludingGravity.x;
    // Send accelX to ARC using AJAX
  });
}

3. Send Data to ARC: Once you have the accelerometer's X value, you can send it to ARC by making an AJAX request to the /script.cmd endpoint with the appropriate EZ-Script command to set the $AccelX variable. Here's an example of how you might do this:

function sendAccelDataToARC(accelX) {
  var xhttp = new XMLHttpRequest();
  xhttp.onreadystatechange = function() {
    if (this.readyState == 4 && this.status == 200) {
      // Handle response if needed
    }
  };
  var ezScriptCommand = "setVar($AccelX, " + accelX + ")";
  xhttp.open("GET", "/script.cmd?script=" + encodeURIComponent(ezScriptCommand), true);
  xhttp.send();
}

4. HTML Button with OnClick Event: Modify the HTML button to call the sendAccelDataToARC function when clicked, passing the accelerometer's X value:

<button onclick="sendAccelDataToARC(accelX)">Send Accel Data to ARC</button>

5. Complete Integration: Ensure that your custom HTML page with the modified button is placed in the HTTP Server Root folder as specified by the HTTP Server (Custom) robot skill. When you click the button on your phone, it should send the accelerometer's X value to ARC, setting the $AccelX variable.

Remember to test this setup thoroughly to ensure that the accelerometer data is being captured and sent correctly to ARC. You may need to adjust the JavaScript code based on the specific requirements of your project and the capabilities of the phone's browser.

@Athena, now can we map the accelerometer output to a value between 1 - 180 before it's sent?

To map the accelerometer output to a value between 1 and 180 before sending it to ARC, you can use a mapping function in your JavaScript code. The mapping function will take the accelerometer's X value, which typically ranges from -1 to 1 (or -10 to 10 depending on the device and browser), and convert it to a value within the desired servo range.

Here's an example of how you might implement the mapping function and integrate it with the code to send the accelerometer data to ARC:

// Function to map a value from one range to another
function map(value, inMin, inMax, outMin, outMax) {
  return (value - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
}

// Function to send accelerometer data to ARC
function sendAccelDataToARC(accelX) {
  // Map the accelerometer's X value to the servo range (1-180)
  var servoValue = map(accelX, -10, 10, 1, 180);
  servoValue = Math.max(1, Math.min(180, Math.round(servoValue))); // Clamp and round the value

  // Construct the  EZ-Script command to set the $AccelX variable
  var ezScriptCommand = "setVar($AccelX, " + servoValue + ")";

  // Send the command to ARC using AJAX
  var xhttp = new XMLHttpRequest();
  xhttp.onreadystatechange = function() {
    if (this.readyState == 4 && this.status == 200) {
      // Handle response if needed
    }
  };
  xhttp.open("GET", "/script.cmd?script=" + encodeURIComponent(ezScriptCommand), true);
  xhttp.send();
}

// Event listener for device motion
if (window.DeviceMotionEvent) {
  window.addEventListener("devicemotion", function(event) {
    var accelX = event.accelerationIncludingGravity.x;
    sendAccelDataToARC(accelX); // Send mapped value to ARC
  });
}

In this example, the map function takes the accelerometer's X value and maps it from its original range (-10 to 10) to the servo range (1 to 180). The Math.max and Math.min functions are used to clamp the value within the 1-180 range, and Math.round is used to round the value to the nearest integer.

The sendAccelDataToARC function now calls the map function to convert the accelerometer value before constructing the EZ-Script command.

Make sure to adjust the input range in the map function according to the actual range of accelerometer values provided by your device. The output range is already set to 1-180 for the servo.