Problem Connecting Final VL53L0X Sensor

welcometothefuture · August 31, 2023, 6:04am

This current project is running 6 TOF sensors as well as 6 servos. I am currently able to connect 5 sensors to the I2C bus, however, when I connect the sensor on A2 to pins A4 and A5, none of the other sensors work; The servo driver that also runs on the I2C bus still functions, however. After testing different sensors and various other things, here's what I know for sure:

The sensor I am trying to connect is functional, and I can get a reading from it if I swap it to another sensor's pins.
The A2 pin doesn't seem to be the issue, because the issue persists if I connect it to A6 instead.
All of the other functions of the code work without any issues if I disconnect the SDA and SCL pins to this sensor, and I can even leave the VCC, GND, and XSHUT pins in.

Here's the code I followed to initialize and read from multiple sensors:

Here's my code:

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>
#include <VL53L0X.h>
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
VL53L0X pinch1;
VL53L0X grab1;
VL53L0X wrist1;
VL53L0X wrist2;
VL53L0X wrist3;
VL53L0X open1;
#define SERVOMINSTOP 100
#define SERVOMIN  (120) // This is the 'minimum' pulse length count (out of 4096)
#define SERVOMID 300
#define SERVOMID4 210
#define SERVOMAX  (400) // This is the 'maximum' pulse length count (out of 4096)
#define SERVOMAXSTOP 210
#define SERVOMAXSTOP1 200
#define SERVOMAXSTOP2 250
#define SERVO_FREQ 50 // Analog servos run at ~50 Hz updates
//int sensorPin = A0;
//int sensorPin1 = A1;
//int sensorPin2 = A2;// select the input pin for the potentiometer      // select the pin for the LED
int grabstate=0;
int wriststate=0;
int w;
int o;
int g;
int p;
int w2;
int w3;
//unsigned long duration;
//unsigned long duration1;
//unsigned long duration2;
struct servo {
  int id;
   int minPos;
   int midPos;
   int maxPos;
   int maxPos2;
};
//void servoUp(struct servo servoID) {
//  Serial.println(servoID.id);
//    for (uint16_t pulselen = servoID.minPos; pulselen < servoID.maxPos; pulselen++) {
//    pwm.setPWM(servoID.id, 0, pulselen);
//    }
//    Serial.println("Done Up");
//}
//
//void servoDown(struct servo servoID) {
//  Serial.println(servoID.id);
//    for (uint16_t pulselen = servoID.maxPos; pulselen > servoID.minPos; pulselen--) {
//    pwm.setPWM(servoID.id, 0, pulselen);
//    }
//    Serial.println("Done Down");
//}
// our servo # counter
//uint8_t servonum = 0;
struct servo servo0; 
struct servo servo1; 
struct servo servo2;
struct servo servo3;
struct servo servo4;
struct servo servo5;

void setup() {
  servo0.id = 0;
  servo0.minPos = SERVOMINSTOP; 
  servo0.midPos = SERVOMID;
  servo0.maxPos = SERVOMAXSTOP;
  servo1.id = 1;
  servo1.minPos = SERVOMIN;
  servo1.midPos = SERVOMID;
  servo1.maxPos = SERVOMAX;
  servo1.maxPos2 = SERVOMAXSTOP1;
  servo2.id = 2;
  servo2.minPos = SERVOMIN;
  servo2.midPos = SERVOMID;
  servo2.maxPos = SERVOMAX;
  servo2.maxPos2 = SERVOMAXSTOP2;
  servo3.id = 3;
  servo3.minPos = SERVOMIN;
  servo3.midPos = SERVOMID;
  servo3.maxPos = SERVOMAX;
  servo4.id = 4;
  servo4.minPos = SERVOMIN;
  servo4.midPos = SERVOMID4;
  servo4.maxPos = SERVOMAX;
  servo5.id = 5;
  servo5.minPos = SERVOMIN;
  servo5.midPos = SERVOMID4;
  servo5.maxPos = SERVOMAX;
  pwm.begin();
  pwm.setOscillatorFrequency(27000000);
  pwm.setPWMFreq(SERVO_FREQ);  // Analog servos run at ~50 Hz updates
  delay(10);
  pinMode(A3, OUTPUT); 
  pinMode(A2, OUTPUT);  
  pinMode(A1, OUTPUT);
  pinMode(A0, OUTPUT);
  pinMode(13, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(2, OUTPUT);
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);
  digitalWrite(6, LOW);
  digitalWrite(7, LOW);
  digitalWrite(8, LOW);
  digitalWrite(9, LOW);
  digitalWrite(10, LOW);
  digitalWrite(11, LOW);
  digitalWrite(12, LOW);
  digitalWrite(13, LOW);
  digitalWrite(A0, LOW);
  digitalWrite(A1, LOW);
  digitalWrite(A2, LOW);
  digitalWrite(A3, LOW);
  delay(500);
  Wire.begin();
  Serial.begin(9600);
 digitalWrite(6, HIGH);
  delay(150);
  Serial.println("00");
  pinch1.init(true);

  Serial.println("01");
  delay(100);
  pinch1.setAddress((uint8_t)01);
  Serial.println("02");

  digitalWrite(4, HIGH);
    delay(150);
  grab1.init(true);
  Serial.println("03");
  delay(100);
  grab1.setAddress((uint8_t)02);
  Serial.println("04");
  
  digitalWrite(A1, HIGH);
  delay(150);
  Serial.println("10");
  wrist1.init(true);

  Serial.println("11");
  delay(100);
  wrist1.setAddress((uint8_t)03);
  Serial.println("12");
  
  digitalWrite(A0, HIGH);
  delay(150);
  Serial.println("13");
  open1.init(true);

  Serial.println("14");
  delay(100);
  open1.setAddress((uint8_t)05);
  Serial.println("15");

  digitalWrite(A2, HIGH);
  delay(150);
  Serial.println("13");
  wrist2.init(true);

  Serial.println("14");
  delay(100);
  wrist2.setAddress((uint8_t)06);
  Serial.println("15");
  Serial.println("addresses set");
  digitalWrite(A3, HIGH);
  delay(150);
  Serial.println("13");
  wrist3.init(true);

  Serial.println("14");
  delay(100);
  wrist3.setAddress((uint8_t)07);
  Serial.println("15");
  Serial.println("addresses set");
  servoMinUpToMax(servo3);
  delay(100);
  servoMaxDownToMin(servo1);
  servoMaxDownToMin(servo2);
  servoMinUpToMax(servo4);  
  servoMaxDownToMin(servo0);
  servoMinUpToMax(servo5);
pinch1.startContinuous();
grab1.startContinuous();
wrist1.startContinuous();
wrist2.startContinuous();
wrist3.startContinuous();
open1.startContinuous();
}
// You can use this function if you'd like to set the pulse length in seconds
// e.g. setServoPulse(0, 0.001) is a ~1 millisecond pulse width. It's not precise!
void setServoPulse(uint8_t n, double pulse) {
  double pulselength;
  
  pulselength = 1000000;   // 1,000,000 us per second
  pulselength /= SERVO_FREQ;   // Analog servos run at ~60 Hz updates
  Serial.print(pulselength); Serial.println(" us per period"); 
  pulselength /= 4096;  // 12 bits of resolution
  Serial.print(pulselength); Serial.println(" us per bit"); 
  pulse *= 1000000;  // convert input seconds to us
  pulse /= pulselength;
  Serial.println(pulse);
  pwm.setPWM(n, 0, pulse);
}

void servoMinUpToMid(struct servo servoID) {
  Serial.println(servoID.id);
    for (uint16_t pulselen = servoID.minPos; pulselen < servoID.midPos; pulselen++) {
    pwm.setPWM(servoID.id, 0, pulselen);
    }
    Serial.println("Done MinUpToMid");
}

void servoMaxDownToMid(struct servo servoID) {
  Serial.println(servoID.id);
    for (uint16_t pulselen = servoID.maxPos; pulselen > servoID.midPos; pulselen--) {
    pwm.setPWM(servoID.id, 0, pulselen);
    }
    Serial.println("Done MaxDownToMid");
}

void servoMidUpToMax(struct servo servoID) {
  Serial.println(servoID.id);
    for (uint16_t pulselen = servoID.midPos; pulselen < servoID.maxPos; pulselen++) {
    pwm.setPWM(servoID.id, 0, pulselen);
    }
    Serial.println("Done MidUpToMax");
}

void servoMidDownToMin(struct servo servoID) {
  Serial.println(servoID.id);
    for (uint16_t pulselen = servoID.midPos; pulselen > servoID.minPos; pulselen--) {
    pwm.setPWM(servoID.id, 0, pulselen);
    }
    Serial.println("Done MidDownToMin");
}

void servoMaxDownToMin(struct servo servoID) {
  Serial.println(servoID.id);
    for (uint16_t pulselen = servoID.maxPos; pulselen > servoID.minPos; pulselen--) {
    pwm.setPWM(servoID.id, 0, pulselen);
    }
    Serial.println("Done MaxDownToMin");

}

void servoMinUpToMax(struct servo servoID) {
  Serial.println(servoID.id);
    for (uint16_t pulselen = servoID.minPos; pulselen < servoID.maxPos; pulselen++) {
    pwm.setPWM(servoID.id, 0, pulselen);
    }
    Serial.println("MinUpToMax");
}

void servoMinUpToMax2(struct servo servoID) {
  Serial.println(servoID.id);
    for (uint16_t pulselen = servoID.minPos; pulselen < servoID.maxPos2; pulselen++) {
    pwm.setPWM(servoID.id, 0, pulselen);
    }
    Serial.println("MinUpToMax");
}

void loop() {
      g=grab1.readRangeContinuousMillimeters();
     // if (!grab1.timeoutOccurred()){
      if ((g < 60)&&(g>1)&&(grabstate==0)&&(wriststate==0)) {
      servoMinUpToMid(servo2);
      servoMaxDownToMid(servo5);
      servoMaxDownToMid(servo3);
      servoMaxDownToMid(servo4);
      delay(50);
      servoMinUpToMid(servo1);
      grabstate=1;
      }
     // }
      g=grab1.readRangeContinuousMillimeters();
      Serial.print(g);
//      if (!grab1.timeoutOccurred()){
        if((g < 50)&&(g>1)&&(grabstate==0)&&(wriststate==1)){
      servoMinUpToMax(servo1);
      servoMinUpToMax(servo2);
      servoMaxDownToMin(servo4);
      servoMaxDownToMin(servo5);
      delay(50);
      servoMaxDownToMin(servo3);
      grabstate=1;
      }
    //  }
      p=pinch1.readRangeContinuousMillimeters();
      Serial.print(p);
//      if (!pinch1.timeoutOccurred()){
        if ((p < 50)&&(p>1)&&(grabstate==0)) {
      servoMinUpToMax2(servo2);
      delay(50);
      servoMinUpToMax2(servo1);
      grabstate=1;
      }
//      }
      o=open1.readRangeContinuousMillimeters();
      Serial.print(o);
 //     if (!open1.timeoutOccurred()){
      if ((o < 40)&&(o>1)) {
      servoMinUpToMax(servo3);
      delay(100);
      servoMaxDownToMin(servo1);
      servoMaxDownToMin(servo2);
      servoMinUpToMax(servo4);  
      servoMinUpToMax(servo5);
      delay(3000);
      grabstate=0;
      }
    //  }
      w=wrist1.readRangeContinuousMillimeters();
      w3=wrist3.readRangeContinuousMillimeters();
      Serial.print(w);
    //  if (!wrist1.timeoutOccurred()){
      if (((w < 80)&&(w>1)&&(grabstate==0)&&(wriststate==0))||((w3 < 80)&&(w3>1)&&(grabstate==0)&&(wriststate==0))) {
      servoMinUpToMax(servo0);
      delay(3000);
      wriststate=1;
      }
     // }
     if (wriststate==1){
      w2=wrist2.readRangeContinuousMillimeters();
      Serial.print(w2);
     // if (!wrist2.timeoutOccurred()){
      if ((w2 < 100)&&(w2>1)&&(grabstate==0)&&(wriststate==1)) {
      servoMaxDownToMin(servo0);
      wriststate=0;
      }
    //  }
     }
      else{
    }
  }

And here's my wiring diagram:

groundFungus · August 31, 2023, 7:55am

How many of those I2C devices have pullup resistors on their module PC boards? What is the resultant pullup resistance with all of those pullups in parallel?

welcometothefuture · August 31, 2023, 8:46am

The TOF sensors (the purple modules) each have a pullup resistor with 10kΩ, for a total of roughly 1.67kΩ. I looked at the documentation, and the servo driver's resistors can be disabled. Should I try disabling the pullup resistors on the servo driver?

groundFungus · August 31, 2023, 11:54am

Yes, at least for a start. The total should be more than 2K. The safe pullup resistance cslculation is effected by capacitance and other factors, but my reading says 2K, minimum. See this page.

welcometothefuture · August 31, 2023, 6:07pm

Ok, so I did some more testing and reading, and only the internal pullup resistors can be switched off, which only changes things for the digital pins. I believe I would have to physically remove pullup resistors from the vl53L0x sensors. Do you have any guidance on how to go forward with this? How would I resolder this to bypass the external resistors?

groundFungus · August 31, 2023, 6:22pm

You will need to take your soldering iron and unsolder (remove) the pullups from some of the boards.

How long are the wires on the I2C bus? Long wires can cause problems, too.

You might want to try lowering the I2C speed.

welcometothefuture · August 31, 2023, 6:43pm

They’re not very long, all less than a foot.

I found a post on how to bypass the resistors:

It looks like I can’t just take off the whole resistor and resolder, as half of the connections to the resistors need to stay. Is this correct?

welcometothefuture · September 3, 2023, 2:32am

So I've removed the pullup resistors completely. The sensors work still, but I am still having this issue.

groundFungus · September 3, 2023, 4:11am

You haveto have at least one pullup on SDA and one pullup on SCL. The recommended pullup is 4.7K (2 x 10K in parallel).

welcometothefuture · September 3, 2023, 4:49am

Yes I have at least one on SDA and SCL. Could it be anything else?

system · March 1, 2024, 4:50am

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
SDA, SCL problem General Guidance	70	21063	May 5, 2021
zwei VL53L0X Time-of-Flight Sensoren Deutsch	4	3568	May 6, 2021
I2C issues when using 2-VL6180X IR sensors Sensors	5	6955	May 6, 2021
connecting multple VL6180X sensors using i2c protocol Sensors	4	6806	May 6, 2021
A5 pin low and having i2c multipe sensor trouble Programming	13	1620	May 5, 2021

Problem Connecting Final VL53L0X Sensor

Related topics