Using an ADXL345 accelerometer with ARC to control servos in a robot build is indeed possible, but it requires a bit of setup and possibly some custom scripting. The ADXL345 is a popular accelerometer that communicates over I2C, which the EZ-B IoTiny supports. However, ARC does not have a built-in robot skill specifically for the ADXL345 accelerometer. You would need to use the I2C communication capabilities of ARC to interact with the ADXL345.

Here's a general approach to integrating the ADXL345 with ARC for your robot:

1. I2C Communication: First, ensure that your ADXL345 accelerometer is correctly wired to the EZ-B IoTiny. The ADXL345 will communicate with the IoTiny over I2C. You'll need to connect the SDA (data line) and SCL (clock line) from the ADXL345 to the corresponding I2C pins on the IoTiny, along with power (VCC) and ground (GND).

2. Identify the I2C Address: Each I2C device has an address. You'll need to know the I2C address of your ADXL345 accelerometer. This information is typically found in the device's datasheet. Common addresses for the ADXL345 are 0x53 (when the ALT ADDRESS pin is grounded) or 0x1D (when the ALT ADDRESS pin is high).

3. Custom Scripting: Since there isn't a dedicated ADXL345 robot skill in ARC, you'll likely need to write some custom scripts to communicate with the accelerometer over I2C. You can use the I2C.read and I2C.write commands in ARC's scripting languages (JavaScript or Python, EZ-Script) to interact with the ADXL345. You'll need to send the appropriate commands to the ADXL345 to initialize it and read the acceleration data.

4. Servo Control: Once you can read the acceleration data from the ADXL345, you can use that data to control the servos in your robot. For example, you might map the X and Y acceleration values to the movement of the head and arms. This will involve some math to convert the acceleration values to servo positions and some scripting to update the servo positions based on the accelerometer data.

5. Testing and Calibration: It's essential to test and calibrate your setup. Accelerometers can be sensitive to orientation and may require calibration to ensure accurate readings. You'll want to experiment with the mapping between acceleration data and servo positions to get the desired behavior from your robot.

While using the ADXL345 with ARC requires some custom work, it's certainly feasible. The key is to become familiar with I2C communication in ARC and to be comfortable writing scripts to process the accelerometer data and control the servos accordingly.

Why would I need i2c connection when the accelerometer is connected to the PC? Is anyone else willing to add their 2 cents?

If there is a usb version, it would most likely create a COM port on the pc. In this case, you can create a robot skill or communicate with the sensor using the COM functions in ARC scripting

this is the Python COM manual: Com commands

Will ARC accept multiple accelerometers?

Yes, ARC allows up to 65,000 robot skills. You may benefit from the Geting Started guide here. specifically the section about what a robot skill is: synthiam.com/Support/Get-Started/how-to-make-a-robot/robot-skills

@athena

the EZ-bits accelerometer is no longer available for sale.

What accelerometer hardware can I purchase that well work with the existing Synthiam skills ?

Is there a magnetometer or compass that is available to interface with Synthiam skills ?

Thank You

While the EZ-Bits accelerometer is no longer available, you can still use other accelerometers with ARC by utilizing the I2C interface. The ADXL345 accelerometer is a popular choice and can be interfaced with ARC using the I2C protocol. You can find ADXL345 modules that are compatible with I2C, which will allow you to connect them to the EZ-B IoTiny or other EZB controllers.

For a magnetometer or compass, you can consider using the HMC5883L or QMC5883L modules, which are also compatible with the I2C interface. These modules can be used to provide compass functionality and can be integrated into your robot project using ARC.

To interface these sensors with ARC, you can create custom robot skills or use existing I2C communication functions within ARC. Here are some resources to help you get started:

• Creating a Robot Skill
• I2C Communication in ARC

If you have any further questions or need assistance with setting up these sensors, feel free to ask!

Take a look at the existing robot skills that support imu's here: https://synthiam.com/Support/Skills/Skills-Overview#I2C

Maybe choose one of those first. And if the one you want isn't supported, just write the i2c commands in python or javascript in a script robot skill. Many ppl purchase an imu or sensor because "it's available" or "it's affordable" but that doesn't always mean it'll be easy to use if their manual/datasheet isn't good. However, if you can find an arduino library that works with your chosen IMU, i usually find it's easier to make an arduino into a translator, of sorts. Allowing the arudino to do the heavy lifting talking to the IMU with it's messy protocol and transmit the values over UART to the EZB.

Lastly, you can always consider taking an arduino or esp32 EZB firmware and modifying it to include an accelerometer. I feel that would be the most seamless option.

This is an example using the Arduino Leonardo EZB. I added the skeleton for an MPU IMU.  @Athena, can you fill in the relevant MPU6550 code in this firmware? Also can you make sure writing the high and low bytes of the _accel, _gyro and _pose values are correct? Thanks

// ********************************************************************************************
// **                                                                                        **
// ** Arduino Leonardo with MPU6550 IMU EZB Firmware for Synthiam ARC (c) 2024 **
// **                                                                                        **
// ** Updated: December 7, 2024 **
// **                                                                                        **
// **                                                                                        **
// ********************************************************************************************

#include <Servo.h>
#include "SendOnlySoftwareSerial.h"

// The first digital port that is usable on this controller
#define _PortStart 0

// The last digital port on this controller that is usable
#define _PortCnt 14

// The number of analog ports
#define _AnalogPorts 5

// The firmware version that is reported to ARC to notify of capabilities
#define _FIRMWARE_ID 0x0000000E

// The communication baud rate (which doesn't matter on leonardo because the USB device connects at fastest speed it can
#define _BAUD_RATE 115200

// The primary communication interface between ARC and this controller
// This is the USB device for Leonardo
#define COMMUNICATION_PORT Serial

// The amount of RX buffer on the communication interface for EZ-Builder
#define _BUFFER_SIZE 512

// The amount of RX buffer on the Serial 1 (ttl) port
// This is because the default input buffer on the Serial1 is only
// 60 bytes or something... so this buffer will store RX data until
// it's queried by EZ-Builder. This emulates a DMA because arduino
// doesn't have one.
#define _BUFFER_SIZE1 512

// --------------------------------------------------------------------------

// EZB COMM BUFFER
byte         _INPUT_BUFFER[_BUFFER_SIZE];
unsigned int _WRITE_POSITION = 0;
unsigned int _READ_POSITION = 0;

// Serial1 TTL BUFFER
byte         _INPUT_BUFFER1[_BUFFER_SIZE1];
unsigned int _WRITE_POSITION1 = 0;
unsigned int _READ_POSITION1 = 0;
bool         _SERIAL_1_INITIALIZED = false;

// Accelerometer buffer
int _accelX = 0;
int _accelY = 0;
int _accelZ = 0;

// Gyro buffer
int _gyroX = 0;
int _gyroY = 0;
int _gyroZ = 0;

// Pose buffer
int _poseX = 0;
int _poseY = 0;
int _poseZ = 0;

long _BAUD_RATES [] = {
  4800,
  9600,
  19200,
  38400,
  57600,
  115200,
  115200
};

Servo Servos[_PortCnt];

#define CmdUnknown            0
#define CmdReleaseAllServos   1
#define CmdGetUniqueID        2
#define CmdEZBv3              3
#define CmdEZBv4              4
#define CmdSoundBeep          5
#define CmdEZServo            6
#define CmdI2CWrite           10
#define CmdI2CRead            11
#define CmdBootLoader         14
#define CmdSetPWMSpeed        15
#define CmdSetServoSpeed      39
#define CmdPing               0x55
#define CmdSetDigitalPortOn   100
#define CmdSetDigitalPortOff  124
#define CmdGetDigitalPort     148
#define CmdSetServoPosition   172
#define CmdGetADCValue        196
#define CmdSendSerial         204
#define CmdHC_SR04            228
#define CmdGetFirwareID       253
#define CmdSoundStreamCmd     254

// CmdEZBv4 Commands
// ----------------------------------------------------------------------------------
#define CmdV4SetLipoBatteryProtectionState 0
#define CmdV4SetBatteryMonitorVoltage      1
#define CmdV4GetBatteryVoltage             2
#define CmdV4GetCPUTemp                    3

#define CmdV4UARTExpansion0Init            5
#define CmdV4UARTExpansion0Write           6
#define CmdV4UARTExpansion0AvailableBytes  7
#define CmdV4UARTExpansion0Read            8

#define CmdV4UARTExpansion1Init            9
#define CmdV4UARTExpansion1Write           10
#define CmdV4UARTExpansion1AvailableBytes  11
#define CmdV4UARTExpansion1Read            12

#define CmdV4UARTExpansion2Init            13
#define CmdV4UARTExpansion2Write           14
#define CmdV4UARTExpansion2AvailableBytes  15
#define CmdV4UARTExpansion2Read            16

#define CmdV4I2CClockSpeed                 17
#define CmdV4UARTClockSpeed                18
#define CmdV4ResetToDefaults               19

// CmdSoundStreamCmd Commands
// ----------------------------------------------------------------------------------
#define CmdSoundInitStop 0
#define CmdSoundLoad     1
#define CmdSoundPlay     2

// For EZB Comm
bool IsAvail() {

  return _WRITE_POSITION != _READ_POSITION || COMMUNICATION_PORT.available();
}

// For Serial1
bool IsAvail1() {

  return _WRITE_POSITION1 != _READ_POSITION1 || Serial1.available();
}

// For EZB Com
int Avail() {

  if (_READ_POSITION > _WRITE_POSITION)
    return (_BUFFER_SIZE - _READ_POSITION) + _WRITE_POSITION + COMMUNICATION_PORT.available();

  return (_WRITE_POSITION - _READ_POSITION) + COMMUNICATION_PORT.available();
}

// For Serial1
int Avail1() {

  if (_READ_POSITION1 > _WRITE_POSITION1)
    return (_BUFFER_SIZE1 - _READ_POSITION1) + _WRITE_POSITION1 + Serial1.available();

  return (_WRITE_POSITION1 - _READ_POSITION1) + Serial1.available();
}

// For EZB Com
long Read32() {

  return (long)ReadByte() | ((long)ReadByte() << 8) | ((long)ReadByte() << 16) | ((long)ReadByte() << 24);
}

// For Serial1
long Read321() {

  return ReadByte1() | ((long)ReadByte1() << 8) | ((long)ReadByte1() << 16) | ((long)ReadByte1() << 24);
}

// For EZB Com
uint16_t Read16() {

  return (long)ReadByte() | ((long)ReadByte() << 8);
}

// For Serial1
uint16_t Read161() {

  return (long)ReadByte1() | ((long)ReadByte1() << 8);
}

// For EZB Com
byte ReadByte() {

  while (_WRITE_POSITION == _READ_POSITION && COMMUNICATION_PORT.available() == 0);

  while (COMMUNICATION_PORT.available()) {

    _WRITE_POSITION++;

    _INPUT_BUFFER[_WRITE_POSITION % _BUFFER_SIZE] = COMMUNICATION_PORT.read();
  }

  _READ_POSITION++;

  return _INPUT_BUFFER[_READ_POSITION % _BUFFER_SIZE];
}

// For Serial1
byte ReadByte1() {

  while (_WRITE_POSITION1 == _READ_POSITION1 && Serial1.available() == 0);

  while (Serial1.available()) {

    _WRITE_POSITION1++;

    _INPUT_BUFFER1[_WRITE_POSITION1 % _BUFFER_SIZE1] = Serial1.read();
  }

  _READ_POSITION1++;

  return _INPUT_BUFFER1[_READ_POSITION1 % _BUFFER_SIZE1];
}

// For Serial1
void UpdateBuffer1() {

  if (!_SERIAL_1_INITIALIZED)
    return;

  while (Serial1.available()) {

    _WRITE_POSITION1++;

    _INPUT_BUFFER1[_WRITE_POSITION1 % _BUFFER_SIZE1] = Serial1.read();
  }
}

void InitMPU() {

}

void setup() {

  COMMUNICATION_PORT.begin(_BAUD_RATE);

  InitMPU();  
}

void UpdateMPUValues() {

// update the _Accel, _gyro, and _pose here
}

void loop() {

  UpdateBuffer1();

  doEZProtocol();

  UpdateMPUValues();
}

void Write32(long val) {

  COMMUNICATION_PORT.write((byte)(val & 0xff));
  COMMUNICATION_PORT.write((byte)((val >> 8) & 0xff));
  COMMUNICATION_PORT.write((byte)((val >> 16) & 0xff));
  COMMUNICATION_PORT.write((byte)((val >> 24) & 0xff));
}

void Write16(int val) {

  COMMUNICATION_PORT.write((byte)(val & 0xff));
  COMMUNICATION_PORT.write((byte)((val >> 8) & 0xff));
}

#define UNKNOWN_PIN 0xFF

uint8_t getPinMode(uint8_t pin) {

  uint8_t bit = digitalPinToBitMask(pin);
  uint8_t port = digitalPinToPort(pin);

  // I don't see an option for mega to return this, but whatever...
  if (NOT_A_PIN == port)
    return UNKNOWN_PIN;

  // Is there a bit we can check?
  if (0 == bit)
    return UNKNOWN_PIN;

  // Is there only a single bit set?
  if (bit & bit - 1)
    return UNKNOWN_PIN;

  volatile uint8_t *reg, *out;
  reg = portModeRegister(port);
  out = portOutputRegister(port);

  if (*reg & bit)
    return OUTPUT;
  else if (*out & bit)
    return INPUT_PULLUP;
  else
    return INPUT;
}

void doEZProtocol() {

  if (!IsAvail())
    return;

  byte cmd = ReadByte();

  if (cmd == CmdPing) {

    // return as a "Capability Controller"
    COMMUNICATION_PORT.write(222);
  } else if (cmd == CmdGetFirwareID) {

    Write32(_FIRMWARE_ID);
  } else if (cmd == CmdReleaseAllServos) {

    for (int port = _PortStart; port < _PortCnt; port++)
      if (Servos[port].attached())
        Servos[port].detach();
  } else if (cmd >= CmdSetServoPosition && cmd <= CmdSetServoPosition + 23) {

    byte port = cmd - CmdSetServoPosition;
    byte pos = ReadByte();

    if (port >= _PortStart && port <= _PortCnt) {

      if (pos == 0 && Servos[port].attached()) {

        Servos[port].detach();
      } else {

        if (!Servos[port].attached())
          Servos[port].attach(port);

        Servos[port].write(pos);
      }
    }
  } else if (cmd >= CmdSetPWMSpeed && cmd <= CmdSetPWMSpeed + 23) {

    byte port = cmd - CmdSetPWMSpeed;
    byte pos = ReadByte();

    if (port >= _PortStart && port <= _PortCnt) {

      if (Servos[port].attached())
        Servos[port].detach();

      if (getPinMode(port) != OUTPUT)
        pinMode(port, OUTPUT);

      analogWrite(port, map(pos, 0, 100, 0, 255));
    }
  } else if (cmd >= CmdSetDigitalPortOn && cmd <= CmdSetDigitalPortOn + 23) {

    byte port = cmd - CmdSetDigitalPortOn;

    if (port >= _PortStart && port <= _PortCnt) {

      if (Servos[port].attached())
        Servos[port].detach();

      if (getPinMode(port) != OUTPUT)
        pinMode(port, OUTPUT);

      digitalWrite(port, HIGH);
    }
  } else if (cmd >= CmdSetDigitalPortOff && cmd <= CmdSetDigitalPortOff + 23) {

    byte port = cmd - CmdSetDigitalPortOff;

    if (port >= _PortStart && port <= _PortCnt) {

      if (Servos[port].attached())
        Servos[port].detach();

      if (getPinMode(port) != OUTPUT)
        pinMode(port, OUTPUT);

      digitalWrite(port, LOW);
    }
  } else if (cmd >= CmdGetDigitalPort && cmd <= CmdGetDigitalPort + 23) {

    byte port = cmd - CmdGetDigitalPort;

    if (port >= _PortStart && port <= _PortCnt) {

      if (Servos[port].attached())
        Servos[port].detach();

      if (getPinMode(port) != INPUT)
        pinMode(port, INPUT);

      COMMUNICATION_PORT.write(digitalRead(port));
    } else {

      COMMUNICATION_PORT.write((byte)0);
    }
  } else if (cmd >= CmdGetADCValue && cmd <= CmdGetADCValue + 7) {

    byte port = cmd - CmdGetADCValue;

    if (port >= 0 && port <= _AnalogPorts)
      Write16(analogRead(port));
    else
      Write16((byte)0);
  } else if (cmd >= CmdSendSerial && cmd <= CmdSendSerial + 23) {

    // Send Serial
    uint8_t port = cmd - CmdSendSerial;
    uint8_t baud = ReadByte(); // Baud rate
    uint8_t size = ReadByte(); // Size

    if (port >= _PortStart && port <= _PortCnt) {

      if (Servos[port].attached())
        Servos[port].detach();

      SendOnlySoftwareSerial tmpSerial(port);

      tmpSerial.begin(_BAUD_RATES[baud]);

      for (int x = 0; x < size; x++)
        tmpSerial.write(ReadByte());

      tmpSerial.end();
    }
  } else if (cmd == CmdEZBv4) {

    byte cmd2 = ReadByte();

    // ------------ UART #0 (i.e. Serial1)
    if (cmd2 == CmdV4UARTExpansion0Init) {

      // reset the input buffer
      _WRITE_POSITION1 = 0;
      _READ_POSITION1 = 0;

      Serial1.begin(Read32());

      _SERIAL_1_INITIALIZED = true;
    } else if (cmd2 == CmdV4UARTExpansion0Write) {

      uint16_t length = Read16();

      for (uint16_t x = 0; x < length; x++)
        Serial1.write(ReadByte());

      // Flush the output send buffer
      Serial1.flush();
    } else if (cmd2 == CmdV4UARTExpansion0AvailableBytes) {

      Write16(Avail1());
    } else if (cmd2 == CmdV4UARTExpansion0Read) {

      uint16_t length = Read16();

      for (uint16_t x = 0; x < length; x++)
        COMMUNICATION_PORT.write(ReadByte1());
    }

    // ------------ UART #1 (i.e. MPU6550 INTERACTION)
    if (cmd2 == CmdV4UARTExpansion1Init) {

      // No need to do anything here becuase the mpu is initialized on power-on. This just
      // reads in the data if you sent an init from ARC and ignores it.
      Read32();
    } else if (cmd2 == CmdV4UARTExpansion1Write) {

      // No need to do anything here because there's no point to writing to the mpu. Just
      // read in the data from ARC and ignore it.
      uint16_t length = Read16();

      for (uint16_t x = 0; x < length; x++)
        ReadByte();
    } else if (cmd2 == CmdV4UARTExpansion1AvailableBytes) {

      // Always write the 18 bytes available because there will always be 18 bytes for the
      // accel, gyro, and pose data
      Write16(18);
    } else if (cmd2 == CmdV4UARTExpansion1Read) {

      // how many bytes to read (ideally 18 becuase that's all we have available)
      // If more than 18 is entered, we just fill the rest with 0's
      // If less than 18 is entered, we send only what's requested
      uint16_t length = Read16();

      for (uint16_t x = 0; x < length; x++) {

        switch (x) {
          case 0:
            // high byte
            COMMUNICATION_PORT.write((byte)(_accelX << 8)); 
            break;
          case 1:
            // low byte
            COMMUNICATION_PORT.write((byte)(_accelX & 0xff)); 
            break;

          case 2:
            // high byte
            COMMUNICATION_PORT.write((byte)(_accelY << 8)); 
            break;
          case 3:
            // low byte
            COMMUNICATION_PORT.write((byte)(_accelY & 0xff)); 
            break;

          case 4:
            // high byte
            COMMUNICATION_PORT.write((byte)(_accelZ << 8)); 
            break;
          case 5:
            // low byte
            COMMUNICATION_PORT.write((byte)(_accelZ & 0xff)); 
            break;

          case 6:
            // high byte
            COMMUNICATION_PORT.write((byte)(_gyroX << 8)); 
            break;
          case 7:
            // low byte
            COMMUNICATION_PORT.write((byte)(_gyroX & 0xff)); 
            break;

          case 8:
            // high byte
            COMMUNICATION_PORT.write((byte)(_gyroY << 8)); 
            break;
          case 9:
            // low byte
            COMMUNICATION_PORT.write((byte)(_gyroY & 0xff)); 
            break;

          case 10:
            // high byte
            COMMUNICATION_PORT.write((byte)(_gyroZ << 8)); 
            break;
          case 11:
            // low byte
            COMMUNICATION_PORT.write((byte)(_gyroZ & 0xff)); 
            break;

          case 12:
            // high byte
            COMMUNICATION_PORT.write((byte)(_poseX << 8)); 
            break;
          case 13:
            // low byte
            COMMUNICATION_PORT.write((byte)(_poseX & 0xff)); 
            break;

          case 14:
            // high byte
            COMMUNICATION_PORT.write((byte)(_poseY << 8)); 
            break;
          case 15:
            // low byte
            COMMUNICATION_PORT.write((byte)(_poseY & 0xff)); 
            break;

          case 16:
            // high byte
            COMMUNICATION_PORT.write((byte)(_poseZ << 8)); 
            break;
          case 17:
            // low byte
            COMMUNICATION_PORT.write((byte)(_poseZ & 0xff)); 
            break;
          default:
            COMMUNICATION_PORT.write((byte)0); 
            break;
        }
      }
    }

    // ------------ UART #2 (i.e. dummy)
    if (cmd2 == CmdV4UARTExpansion2Init) {

      Read32();
    } else if (cmd2 == CmdV4UARTExpansion2Write) {

      uint16_t length = Read16();

      for (uint16_t x = 0; x < length; x++)
        ReadByte();
    } else if (cmd2 == CmdV4UARTExpansion2AvailableBytes) {

      Write16((byte)0);
    } else if (cmd2 == CmdV4UARTExpansion2Read) {

      uint16_t length = Read16();

      for (uint16_t x = 0; x < length; x++)
        COMMUNICATION_PORT.write((byte)0);
    }
  }
}

To integrate the MPU6050 (or MPU6550 as mentioned) with the Arduino Leonardo and communicate with Synthiam ARC, you can use the MPU6050 library to handle the sensor data. Below is a modified version of your Arduino sketch that includes the necessary code to read data from the MPU6050 and send it to ARC.

First, ensure you have the MPU6050 library installed in your Arduino IDE. You can install it via the Library Manager by searching for "MPU6050".

Here's the updated code:

#include <Wire.h>
#include <MPU6050.h>
#include <SendOnlySoftwareSerial.h>

// The first digital port that is usable on this controller
#define _PortStart 0

// The last digital port on this controller that is usable
#define _PortCnt 14

// The number of analog ports
#define _AnalogPorts 5

// The firmware version that is reported to ARC to notify of capabilities
#define _FIRMWARE_ID 0x0000000E

// The communication baud rate
#define _BAUD_RATE 115200

// The primary communication interface between ARC and this controller
#define COMMUNICATION_PORT Serial

// The amount of RX buffer on the communication interface for EZ-Builder
#define _BUFFER_SIZE 512

// The amount of RX buffer on the Serial 1 (ttl) port
#define _BUFFER_SIZE1 512

// For EZB Comm
byte _INPUT_BUFFER[_BUFFER_SIZE];
unsigned int _WRITE_POSITION = 0;
unsigned int _READ_POSITION = 0;

// For Serial1
byte _INPUT_BUFFER1[_BUFFER_SIZE1];
unsigned int _WRITE_POSITION1 = 0;
unsigned int _READ_POSITION1 = 0;
bool _SERIAL_1_INITIALIZED = false;

// Accelerometer buffer
int _accelX = 0;
int _accelY = 0;
int _accelZ = 0;

// Gyro buffer
int _gyroX = 0;
int _gyroY = 0;
int _gyroZ = 0;

// Pose buffer
int _poseX = 0;
int _poseY = 0;
int _poseZ = 0;

long _BAUD_RATES[] = {4800, 9600, 19200, 38400, 57600, 115200, 115200};
Servo Servos[_PortCnt];

MPU6050 mpu;

void setup() {
  Wire.begin();
  COMMUNICATION_PORT.begin(_BAUD_RATE);
  mpu.initialize();
  if (!mpu.testConnection()) {
    while (1) {
      // Failed to connect to MPU6050
    }
  }
}

void loop() {
  doEZProtocol();
  updateMPUData();
}

void updateMPUData() {
  mpu.getMotion6(&_accelX, &_accelY, &_accelZ, &_gyroX, &_gyroY, &_gyroZ);
  // Convert raw data to meaningful values if needed
  // For example, convert to g's or degrees per second
}

void doEZProtocol() {
  if (!IsAvail()) return;
  byte cmd = ReadByte();
  if (cmd == CmdPing) {
    COMMUNICATION_PORT.write(222);
  } else if (cmd == CmdGetFirwareID) {
    Write32(_FIRMWARE_ID);
  } else if (cmd == CmdReleaseAllServos) {
    for (int port = _PortStart; port <= _PortCnt; port++) {
      if (Servos[port].attached()) Servos[port].detach();
    }
  } else if (cmd == CmdSetServoPosition) {
    // Handle servo position command
  } else if (cmd == CmdGetADCValue) {
    // Handle ADC value command
  } else if (cmd == CmdSendSerial) {
    // Handle serial send command
  } else if (cmd == CmdEZBv4) {
    byte cmd2 = ReadByte();
    if (cmd2 == CmdV4UARTExpansion1Read) {
      uint16_t length = Read16();
      for (uint16_t x = 0; x < length; x++) {
        switch (x) {
          case 0: COMMUNICATION_PORT.write((byte)(_accelX >> 8)); break;
          case 1: COMMUNICATION_PORT.write((byte)(_accelX & 0xff)); break;
          case 2: COMMUNICATION_PORT.write((byte)(_accelY >> 8)); break;
          case 3: COMMUNICATION_PORT.write((byte)(_accelY & 0xff)); break;
          case 4: COMMUNICATION_PORT.write((byte)(_accelZ >> 8)); break;
          case 5: COMMUNICATION_PORT.write((byte)(_accelZ & 0xff)); break;
          case 6: COMMUNICATION_PORT.write((byte)(_gyroX >> 8)); break;
          case 7: COMMUNICATION_PORT.write((byte)(_gyroX & 0xff)); break;
          case 8: COMMUNICATION_PORT.write((byte)(_gyroY >> 8)); break;
          case 9: COMMUNICATION_PORT.write((byte)(_gyroY & 0xff)); break;
          case 10: COMMUNICATION_PORT.write((byte)(_gyroZ >> 8)); break;
          case 11: COMMUNICATION_PORT.write((byte)(_gyroZ & 0xff)); break;
          default: COMMUNICATION_PORT.write((byte)0); break;
        }
      }
    }
  }
}

bool IsAvail() {
  return _WRITE_POSITION != _READ_POSITION || COMMUNICATION_PORT.available();
}

int Avail() {
  if (_READ_POSITION > _WRITE_POSITION)
    return (_BUFFER_SIZE - _READ_POSITION) + _WRITE_POSITION + COMMUNICATION_PORT.available();
  return (_WRITE_POSITION - _READ_POSITION) + COMMUNICATION_PORT.available();
}

byte ReadByte() {
  if (_READ_POSITION == _WRITE_POSITION) {
    while (!COMMUNICATION_PORT.available());
    return COMMUNICATION_PORT.read();
  }
  byte b = _INPUT_BUFFER[_READ_POSITION++];
  if (_READ_POSITION == _BUFFER_SIZE) _READ_POSITION = 0;
  return b;
}

void Write32(long val) {
  COMMUNICATION_PORT.write((byte)(val & 0xff));
  COMMUNICATION_PORT.write((byte)((val >> 8) & 0xff));
  COMMUNICATION_PORT.write((byte)((val >> 16) & 0xff));
  COMMUNICATION_PORT.write((byte)((val >> 24) & 0xff));
}

Key Points:

• The MPU6050 library is used to interface with the MPU6050 sensor.
• The updateMPUData() function reads the accelerometer and gyroscope data from the MPU6050.
• The doEZProtocol() function handles communication with ARC, including sending sensor data.
• The sensor data is sent as high and low bytes to ARC.

This code provides a basic framework for integrating the MPU6050 with ARC. You can expand upon this by adding more functionality or refining the data processing as needed. If you have any further questions or need additional assistance, feel free to ask!