Luis Vega
Published © MIT

Garbage

Smart Garbage

IntermediateFull instructions provided8 hours62
Garbage

Things used in this project

Hardware components

Argon
Particle Argon
×1
Fermion: VL53L3CX ToF Distance Ranging Sensor (Breakout)
DFRobot Fermion: VL53L3CX ToF Distance Ranging Sensor (Breakout)
×1
Fermion: VL53L3CX ToF Distance Ranging Sensor (Breakout)
DFRobot Fermion: VL53L3CX ToF Distance Ranging Sensor (Breakout)
×1
Jumper wires (generic)
Jumper wires (generic)
×1
Breadboard (generic)
Breadboard (generic)
×1
Servo motor
×1

Software apps and online services

VS Code
Microsoft VS Code
Particle Build Web IDE
Particle Build Web IDE
particle workbench

Hand tools and fabrication machines

Hot glue gun (generic)
Hot glue gun (generic)
Multitool, Screwdriver
Multitool, Screwdriver
Soldering iron (generic)
Soldering iron (generic)

Story

Read more

Schematics

Schematic

Hardware pinout

Code

Particle Argon Code

Processing
Use with Particle Argon
/**
 * @file garbage.ino
 * @author Luis Vega (lvega1@uncc.edu)
 * @brief Garage lid with ToF sensors for open lid and send notification
 *        if gargabe is full.
 * @version 0.1
 * @date 2022-10-09
 *
 * @copyright Copyright (c) 2022
 *
 */

#pragma region Garbage project {
  #include <Wire.h>
  #include "SparkFun_VL53L5CX.h"
  #include "Adafruit_VL6180X.h"

  #pragma region NOTIFICATION_FUNCTIONALITY {
    time32_t lastTime = 0; // seconds
    double avg_fill_dist = 0.0;
    SparkFun_VL53L5CX myImager;
    VL53L5CX_ResultsData measurementData; // Result data class structure, 1356 byes of RAM

    int imageResolution = 0; //Used to pretty print output
    int imageWidth = 0; //Used to pretty print output

    void WH_Hndlr(const char *event, const char *data);
    void VL53L5CX_ERROR_CB(SF_VL53L5CX_ERROR_TYPE errorCode, uint32_t errorValue);
  #pragma endregion } NOTIFICATION_FUNCTIONALITY
  #pragma region LID_FUNCTIONALITY {
    int  range = 0;
    int status = 0;
    double lux = 0.0;
    Adafruit_VL6180X vl = Adafruit_VL6180X();

    bool manual = false;
    int ds_min = 300; // 290
    int ds_max = 1150; // 1980
    int val;    // variable to read the value from the analog pin
    Servo ds;
  #pragma endregion } LID_FUNCTIONALITY

  void setup() {
    Wire.begin(); //This resets to 100kHz I2C
    Wire.setClock(400000); //Sensor has max I2C freq of 400kHz

    #pragma region NOTIFICATION_FUNCTIONALITY {
      #pragma region SparkFun_VL53L5CX {
        delay(1000);

        myImager.setErrorCallback(VL53L5CX_ERROR_CB);
        while(!myImager.begin()) {
          Particle.publish("ToF-Test", "Failed to find VL53L5CX sensor. Testing address 0x29...", PRIVATE);
          delay(100);
          if(myImager.begin(0x29)) break;
          // Particle.publish("ToF-Test", "failed", PRIVATE);
          delay(5000);
        }


        // while(!myImager.setAddress(0x44));
        // if(myImager.setAddress(0x44) == false) {
        //   Particle.publish("ToF-Test", "Device failed to set new address. Please try again. Freezing...", PRIVATE);
        // };

        delay(500);

        myImager.setResolution(8 * 8); //Enable all 64 pads
        imageResolution = myImager.getResolution(); //Query sensor for current resolution - either 4x4 or 8x8
        imageWidth = sqrt(imageResolution); //Calculate printing width

        myImager.startRanging();
      #pragma endregion } SparkFun_VL53L5CX

      Particle.variable("avg_fill_dist", avg_fill_dist);

      // Subscribe to the integration response event
      Particle.subscribe("hook-response/garbage_full", WH_Hndlr, MY_DEVICES);
    #pragma endregion } NOTIFICATION_FUNCTIONALITY
    #pragma region LID_FUNCTIONALITY {
      #pragma region Adafruit_VL6180X {
        // Serial.println("Adafruit VL6180x test!");
        Particle.publish("ToF-Test", "Adafruit VL6180x test!", PRIVATE);
        // Particle.publish("ToF-Test", PRIVATE);
        while(!vl.begin()) {
          // Serial.println("Failed to find sensor");
          Particle.publish("ToF-Test", "Failed to find VL6180X sensor", PRIVATE);
          delay(1000);
          // while (true) i2cScanner();
        }
        // Serial.println("Sensor found!");
        Particle.publish("ToF-Test", "Sensor found!", PRIVATE);

        pinMode(A1, OUTPUT);
        analogWriteResolution(A1, 12);

        Particle.variable("Lux", lux);
        Particle.variable("range", range);
        Particle.variable("status", status);
      #pragma endregion } Adafruit_VL6180X
      #pragma region SERVO_FUNCTIONS {
        manual = false;

        Particle.function("setValue", setValue);
        Particle.function("setCloseValue", setCloseValue);
        Particle.function("setOpenValue", setOpenValue);
      #pragma endregion } SERVO_FUNCTIONS
    #pragma endregion } LID_FUNCTIONALITY
  }
  void loop() {
    #pragma region NOTIFICATION_FUNCTIONALITY {
      // Poll sensor for new data
      if (myImager.isDataReady() == true)
      {
        if (myImager.getRangingData(&measurementData)) //Read distance data into array
        {
          //The ST library returns the data transposed from zone mapping shown in datasheet
          //Pretty-print data with increasing y, decreasing x to reflect reality
          avg_fill_dist = 0.0;
          for (int y = 0 ; y <= imageWidth * (imageWidth - 1) ; y += imageWidth)
          {
            for (int x = imageWidth - 1 ; x >= 0 ; x--)
            {
              avg_fill_dist += measurementData.distance_mm[x + y];
              // Serial.print("\t");
              // Serial.print(measurementData.distance_mm[x + y]);
              // Serial.print(measurementData.distance_mm[x + y]);
            }
            // Serial.println();
          }
          avg_fill_dist /= 64.0;

          if(avg_fill_dist < 100 ) {
            if(Time.now() - lastTime > 3600) {
              Particle.publish("garbage_full", String(avg_fill_dist), PRIVATE);
              lastTime = Time.now();
            }
          }
          // Serial.println();
        }
      }
    #pragma endregion } NOTIFICATION_FUNCTIONALITY
    #pragma region LID_FUNCTIONALITY {
      lux = vl.readLux(VL6180X_ALS_GAIN_5);

      // Serial.print("Lux: "); Serial.println(lux);
      // Particle.publish("ToF-Test", "Lux: " +  String(lux), PRIVATE);

      range = vl.readRange();
      status = vl.readRangeStatus();

      if(!manual) {
        if (status == VL6180X_ERROR_NONE) {
          // val = map(range, 5, 200, ds_min, ds_max);     // scale it for use with the servo (value between 0 and 180)
          // analogWrite(A1, val, 180);
          if(range < 100) open();

          // Serial.print("Range: "); Serial.println(range);
          // Particle.publish("ToF-Test", "Range: " + String(range), PRIVATE);
        } else {
          analogWrite(A1, ds_max, 180);
        }

        // // Some error occurred, print it out!

        if  ((status >= VL6180X_ERROR_SYSERR_1) && (status <= VL6180X_ERROR_SYSERR_5)) {
          // Serial.println("System error");
          Particle.publish("ToF-Test", "System error", PRIVATE);
        }
        else if (status == VL6180X_ERROR_ECEFAIL) {
          // Serial.println("ECE failure");
          // Particle.publish("ToF-Test", String(range), PRIVATE);
        }
        else if (status == VL6180X_ERROR_NOCONVERGE) {
          // Serial.println("No convergence");
          // Particle.publish("ToF-Test", "ECE failure", PRIVATE);
        }
        else if (status == VL6180X_ERROR_RANGEIGNORE) {
          // Serial.println("Ignoring range");
          Particle.publish("ToF-Test", "Ignoring range", PRIVATE);
        }
        else if (status == VL6180X_ERROR_SNR) {
          // Serial.println("Signal/Noise error");
          Particle.publish("ToF-Test", "Signal/Noise error", PRIVATE);
        }
        else if (status == VL6180X_ERROR_RAWUFLOW) {
          // Serial.println("Raw reading underflow");
          Particle.publish("ToF-Test", "Raw reading underflow", PRIVATE);
        }
        else if (status == VL6180X_ERROR_RAWOFLOW) {
          // Serial.println("Raw reading overflow");
          Particle.publish("ToF-Test", "Raw reading overflow", PRIVATE);
        }
        else if (status == VL6180X_ERROR_RANGEUFLOW) {
          // Serial.println("Range reading underflow");
          Particle.publish("ToF-Test", "Range reading underflow", PRIVATE);
        }
        else if (status == VL6180X_ERROR_RANGEOFLOW) {
          // Serial.println("Range reading overflow");
          Particle.publish("ToF-Test", "Range reading overflow", PRIVATE);
        }
      } else {
        // val = map(range, 0, 200, 0, 1023);     // scale it for use with the servo (value between 0 and 180)
        analogWrite(A1, val, 180);
      }
    #pragma endregion } LID_FUNCTIONALITY

    delay(50);
  }

  #pragma region SERVO_FUNCTIONS {
    int setOpenValue(String value) {
      int temp = value.toInt();

      if(temp >= 290 && temp < ds_max) {
        ds_min = value.toInt();
      } else {
        return -1;
      }

      return 0;
    }
    int setCloseValue(String value) {
      int temp = value.toInt();

      if(temp > ds_min && temp < 1980) {
        ds_max = value.toInt();
      } else {
        return -1;
      }

      return 0;
    }
    int setValue(String value) {
      int temp = value.toInt();

      if(temp >= 0) {
        manual = true;
        val = temp;
      } else manual = false;

      return 0;
    }
    void open() {
      int temp;

      for(int i = 0; i < 1000; i++) {
        temp = map(i, 1000, 0, ds_min, ds_max);     // scale it for use with the servo (value between 0 and 180)
        analogWrite(A1, temp, 180);
        delay(3);
      }
      do
        range = vl.readRange();
      while(range < 100);
      delay(10000);
      for(int i = 999; i >=0; i--) {
        temp = map(i, 1000, 0, ds_min, ds_max);     // scale it for use with the servo (value between 0 and 180)
        analogWrite(A1, temp, 180);
        delay(3);
      }
    }
  #pragma endregion } SERVO_FUNCTIONS
  #pragma region NOTIFICATION_FUNCTIONALITY {
    void VL53L5CX_ERROR_CB(SF_VL53L5CX_ERROR_TYPE errorCode, uint32_t errorValue) {
      switch(errorCode) {
        case SF_VL53L5CX_ERROR_TYPE::NO_ERROR:
          Particle.publish("ToF-Test", "VL53L5CX no error found", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::I2C_INITIALIZATION_ERROR:
          Particle.publish("ToF-Test", "VL53L5CX error: I2C initialization", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::I2C_NOT_RESPONDING:
          Particle.publish("ToF-Test", "VL53L5CX error: I2C not responding", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::DEVICE_INITIALIZATION_ERROR:
          Particle.publish("ToF-Test", "VL53L5CX error: Device initialization", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::INVALID_DEVICE:
          Particle.publish("ToF-Test",
            "VL53L5CX error: Invalid device (device: " + String(myImager.deviceId) +
            ", revision: " + String(myImager.revisionId) + ")", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::INVALID_FREQUENCY_SETTING:
          Particle.publish("ToF-Test", "VL53L5CX error: Invalid frequency setting", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::INVALID_RANGING_MODE:
          Particle.publish("ToF-Test", "VL53L5CX error: Invalid ranging mode", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::CANNOT_CHANGE_I2C_ADDRESS:
          Particle.publish("ToF-Test", "VL53L5CX error: Cannot change I2C address", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::CANNOT_START_RANGING:
          Particle.publish("ToF-Test", "VL53L5CX error: Cannot start ranging", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::CANNOT_STOP_RANGING:
          Particle.publish("ToF-Test", "VL53L5CX error: Cannot stop ranging", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::CANNOT_GET_DATA_READY:
          Particle.publish("ToF-Test", "VL53L5CX error: Cannot get data ready", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::CANNOT_GET_RESOLUTION:
          Particle.publish("ToF-Test", "VL53L5CX error: Cannot get resolution", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::CANNOT_GET_RANGING_DATA:
          Particle.publish("ToF-Test", "VL53L5CX error: Cannot get ranging data", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::CANNOT_SET_RESOLUTION:
          Particle.publish("ToF-Test", "VL53L5CX error: Cannot set resolution", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::CANNOT_SET_POWER_MODE:
          Particle.publish("ToF-Test", "VL53L5CX error: cannot set power mode", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::CANNOT_GET_POWER_MODE:
          Particle.publish("ToF-Test", "VL53L5CX error: cannot get power mode", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::DEVICE_NOT_ALIVE:
          Particle.publish("ToF-Test", "VL53L5CX error: Device not alive", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::INVALID_INTEGRATION_TIME:
          Particle.publish("ToF-Test", "VL53L5CX error: Invalid integration time", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::CANNOT_SET_INTEGRATION_TIME:
          Particle.publish("ToF-Test", "VL53L5CX error: Cannot set integration time", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::CANNOT_GET_INTEGRATION_TIME:
          Particle.publish("ToF-Test", "VL53L5CX error: Cannot get integration time", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::INVALID_SHARPENER_VALUE:
          Particle.publish("ToF-Test", "VL53L5CX error: Invalid sharpener value", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::CANNOT_SET_SHARPENER_VALUE:
          Particle.publish("ToF-Test", "VL53L5CX error: Cannot set sharpener value", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::CANNOT_GET_SHARPENER_VALUE:
          Particle.publish("ToF-Test", "VL53L5CX error: Cannot get sharpener value", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::CANNOT_SET_TARGET_ORDER:
          Particle.publish("ToF-Test", "VL53L5CX error: Cannot set target order", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::CANNOT_GET_TARGET_ORDER:
          Particle.publish("ToF-Test", "VL53L5CX error: Cannot get target order", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::INVALID_TARGET_ORDER:
          Particle.publish("ToF-Test", "VL53L5CX error: Invalid target order", PRIVATE);
          break;
        case SF_VL53L5CX_ERROR_TYPE::UNKNOWN_ERROR:
          Particle.publish("ToF-Test", "VL53L5CX error: Unknown error", PRIVATE);
          break;
        default:
          Particle.publish("ToF-Test", "undefined VL53L5CX error code ", PRIVATE);
      }
    }
    void WH_Hndlr(const char *event, const char *data) {
      // Handle the integration response
    }
  #pragma endregion } NOTIFICATION_FUNCTIONALITY

  void i2cScanner() {
    byte error, address;
    int nDevices;

    Particle.publish("ToF-Test", "Scanning... ", PRIVATE);

    nDevices = 0;
    for(address = 1; address < 127; address++ )
    {
      // The i2c_scanner uses the return value of
      // the Write.endTransmisstion to see if
      // a device did acknowledge to the address.
      Wire.beginTransmission(address);
      error = Wire.endTransmission();

      if (error == 0)
      {
        // Serial.print("I2C device found at address 0x");
        Particle.publish("ToF-Test", "I2C device found at address " + String(address), PRIVATE);
        nDevices++;
      }
      else if (error==4)
      {
        // Serial.print("Unknown error at address 0x");
        Particle.publish("ToF-Test", "Unknown error at address 0x" + String(address), PRIVATE);
      }
    }
    if (nDevices == 0)
      // Serial.println("No I2C devices found\n");
      Particle.publish("ToF-Test", "No I2C devices found.", PRIVATE);
    else
      // Serial.println("done\n");
      Particle.publish("ToF-Test", "done.", PRIVATE);

    delay(5000);           // wait 5 seconds for next scan
  }
#pragma endregion } Garbage project

#pragma region Webhook Test {
  // void myHandler(const char *event, const char *data);
  // void setup() {
  //   // Subscribe to the integration response event
  //   Particle.subscribe("hook-response/garbage_full", myHandler, MY_DEVICES);
  // }


  // void loop() {
  //   // Get some data
  //   String data = String(10);
  //   // Trigger the integration
  //   Particle.publish("garbage_full", data, PRIVATE);
  //   // Wait 60 seconds
  //   delay(60000);
  // }

  // void myHandler(const char *event, const char *data) {
  //   // Handle the integration response
  // }
#pragma endregion } Webhook Test
#pragma region I2C scanner test {
  /**
   * @brief scans for I2C sensors and prints out their address.
   *
   */

  // #include <Wire.h>

  // void setup()
  // {
  //   Wire.begin();

  //   // while (!Serial);             // Leonardo: wait for serial monitor
  //   Particle.publish("ToF-Test", "I2C Scanner ", PRIVATE);
  // }


  // void loop()
  // {
  //   byte error, address;
  //   int nDevices;

  //   Particle.publish("ToF-Test", "Scanning... ", PRIVATE);

  //   nDevices = 0;
  //   for(address = 1; address < 127; address++ )
  //   {
  //     // The i2c_scanner uses the return value of
  //     // the Write.endTransmisstion to see if
  //     // a device did acknowledge to the address.
  //     Wire.beginTransmission(address);
  //     error = Wire.endTransmission();

  //     if (error == 0)
  //     {
  //       // Serial.print("I2C device found at address 0x");
  //       Particle.publish("ToF-Test", "I2C device found at address 0x" + String(address), PRIVATE);
  //       nDevices++;
  //     }
  //     else if (error==4)
  //     {
  //       // Serial.print("Unknown error at address 0x");
  //       Particle.publish("ToF-Test", "Unknown error at address 0x" + String(address), PRIVATE);
  //     }
  //   }
  //   if (nDevices == 0)
  //     // Serial.println("No I2C devices found\n");
  //     Particle.publish("ToF-Test", "No I2C devices found.", PRIVATE);
  //   else
  //     // Serial.println("done\n");
  //     Particle.publish("ToF-Test", "done.", PRIVATE);

  //   delay(5000);           // wait 5 seconds for next scan
  // }
#pragma endregion } I2C scanner test
#pragma region I2C Change Address test {

//   #include <Wire.h>

//   #include <SparkFun_VL53L5CX.h>

//   SparkFun_VL53L5CX myImager;
//   VL53L5CX_ResultsData measurementData; // Result data class structure, 1356 byes of RAM

//   int imageResolution = 0; //Used to pretty print output
//   int imageWidth = 0; //Used to pretty print output

//   void VL53L5CX_ERROR_CB(SF_VL53L5CX_ERROR_TYPE errorCode, uint32_t errorValue);

//   void setup() {
//     // Serial.begin(115200);
//     delay(1000);
//     // Serial.println("SparkFun VL53L5CX Imager Example");

//     Wire.begin(); //This resets I2C bus to 100kHz
//     Wire.setClock(1000000); //Sensor has max I2C freq of 1MHz

//     // Serial.println(F("Initializing sensor board. This can take up to 10s. Please wait."));
//     myImager.setErrorCallback(VL53L5CX_ERROR_CB);
//     while(!myImager.begin()) {
//       // Particle.publish("ToF-Test", "Sensor not found - running scanner", PRIVATE);
//       Particle.publish("ToF-Test", "Testing address 0x29...", PRIVATE);
//       delay(100);
//       if(myImager.begin(0x29)) break;
//       Particle.publish("ToF-Test", "failed", PRIVATE);
//       // while(true) delay(5000);
//       delay(5000);
//     }

//     // while (Serial.available()) //Clear incoming key presses
//     //   Serial.read();

//     // Serial.println(F("Press any key to set device address to 0x44"));
//     // int deviceAddress = 0x44; //Valid: 0x08 <= address <= 0x77

//     // while (Serial.available() == false) //Clear incoming key presses
//       ; //Do nothing

//     // while(!myImager.setAddress(deviceAddress));
//     // if(myImager.setAddress(deviceAddress) == false) {
//     //   Particle.publish("ToF-Test", "Device failed to set new address. Please try again. Freezing...", PRIVATE);
//     // };

//     delay(500);

//     // int newAddress = myImager.getAddress();

//     // Serial.print(F("New address is: 0x"));
//     // Serial.println(newAddress, HEX);

//     // Serial.println(F("See advanced I2C example to start sensor with new address."));

//     myImager.setResolution(8 * 8); //Enable all 64 pads
//     imageResolution = myImager.getResolution(); //Query sensor for current resolution - either 4x4 or 8x8
//     imageWidth = sqrt(imageResolution); //Calculate printing width

//     myImager.startRanging();
//   }
//   void loop() {
//     i2cScanner();
//   }

//   void VL53L5CX_ERROR_CB(SF_VL53L5CX_ERROR_TYPE errorCode, uint32_t errorValue) {
//     switch(errorCode) {
//       case SF_VL53L5CX_ERROR_TYPE::NO_ERROR:
//         Particle.publish("ToF-Test", "VL53L5CX no error found", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::I2C_INITIALIZATION_ERROR:
//         Particle.publish("ToF-Test", "VL53L5CX error: I2C initialization", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::I2C_NOT_RESPONDING:
//         Particle.publish("ToF-Test", "VL53L5CX error: I2C not responding", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::DEVICE_INITIALIZATION_ERROR:
//         Particle.publish("ToF-Test", "VL53L5CX error: Device initialization", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::INVALID_DEVICE:
//         Particle.publish("ToF-Test",
//           "VL53L5CX error: Invalid device (device: " + String(myImager.deviceId) +
//           ", revision: " + String(myImager.revisionId) + ")", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::INVALID_FREQUENCY_SETTING:
//         Particle.publish("ToF-Test", "VL53L5CX error: Invalid frequency setting", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::INVALID_RANGING_MODE:
//         Particle.publish("ToF-Test", "VL53L5CX error: Invalid ranging mode", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::CANNOT_CHANGE_I2C_ADDRESS:
//         Particle.publish("ToF-Test", "VL53L5CX error: Cannot change I2C address", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::CANNOT_START_RANGING:
//         Particle.publish("ToF-Test", "VL53L5CX error: Cannot start ranging", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::CANNOT_STOP_RANGING:
//         Particle.publish("ToF-Test", "VL53L5CX error: Cannot stop ranging", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::CANNOT_GET_DATA_READY:
//         Particle.publish("ToF-Test", "VL53L5CX error: Cannot get data ready", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::CANNOT_GET_RESOLUTION:
//         Particle.publish("ToF-Test", "VL53L5CX error: Cannot get resolution", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::CANNOT_GET_RANGING_DATA:
//         Particle.publish("ToF-Test", "VL53L5CX error: Cannot get ranging data", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::CANNOT_SET_RESOLUTION:
//         Particle.publish("ToF-Test", "VL53L5CX error: Cannot set resolution", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::CANNOT_SET_POWER_MODE:
//         Particle.publish("ToF-Test", "VL53L5CX error: cannot set power mode", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::CANNOT_GET_POWER_MODE:
//         Particle.publish("ToF-Test", "VL53L5CX error: cannot get power mode", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::DEVICE_NOT_ALIVE:
//         Particle.publish("ToF-Test", "VL53L5CX error: Device not alive", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::INVALID_INTEGRATION_TIME:
//         Particle.publish("ToF-Test", "VL53L5CX error: Invalid integration time", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::CANNOT_SET_INTEGRATION_TIME:
//         Particle.publish("ToF-Test", "VL53L5CX error: Cannot set integration time", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::CANNOT_GET_INTEGRATION_TIME:
//         Particle.publish("ToF-Test", "VL53L5CX error: Cannot get integration time", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::INVALID_SHARPENER_VALUE:
//         Particle.publish("ToF-Test", "VL53L5CX error: Invalid sharpener value", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::CANNOT_SET_SHARPENER_VALUE:
//         Particle.publish("ToF-Test", "VL53L5CX error: Cannot set sharpener value", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::CANNOT_GET_SHARPENER_VALUE:
//         Particle.publish("ToF-Test", "VL53L5CX error: Cannot get sharpener value", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::CANNOT_SET_TARGET_ORDER:
//         Particle.publish("ToF-Test", "VL53L5CX error: Cannot set target order", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::CANNOT_GET_TARGET_ORDER:
//         Particle.publish("ToF-Test", "VL53L5CX error: Cannot get target order", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::INVALID_TARGET_ORDER:
//         Particle.publish("ToF-Test", "VL53L5CX error: Invalid target order", PRIVATE);
//         break;
//       case SF_VL53L5CX_ERROR_TYPE::UNKNOWN_ERROR:
//         Particle.publish("ToF-Test", "VL53L5CX error: Unknown error", PRIVATE);
//         break;
//       default:
//         Particle.publish("ToF-Test", "undefined VL53L5CX error code ", PRIVATE);
//     }
//   }
//   void i2cScanner() {
//     byte error, address;
//     int nDevices;

//     Particle.publish("ToF-Test", "Scanning... ", PRIVATE);

//     nDevices = 0;
//     for(address = 1; address < 127; address++ )
//     {
//       // The i2c_scanner uses the return value of
//       // the Write.endTransmisstion to see if
//       // a device did acknowledge to the address.
//       Wire.beginTransmission(address);
//       error = Wire.endTransmission();

//       if (error == 0)
//       {
//         // Serial.print("I2C device found at address 0x");
//         Particle.publish("ToF-Test", "I2C device found at address " + String(address), PRIVATE);
//         nDevices++;
//       }
//       else if (error==4)
//       {
//         // Serial.print("Unknown error at address 0x");
//         Particle.publish("ToF-Test", "Unknown error at address 0x" + String(address), PRIVATE);
//       }
//     }
//     if (nDevices == 0)
//       // Serial.println("No I2C devices found\n");
//       Particle.publish("ToF-Test", "No I2C devices found.", PRIVATE);
//     else
//       // Serial.println("done\n");
//       Particle.publish("ToF-Test", "done.", PRIVATE);

//     delay(5000);           // wait 5 seconds for next scan
//   }
#pragma endregion } I2C Change Address test
#pragma region Servor test {
  /**
   * @brief Test servor to make sure is connected properly
   *
   */
  // int val = 0;    // variable to read the value from the analog pin
  // void setup() {
  //   pinMode(A1, OUTPUT);
  //   analogWriteResolution(A1, 10);
  // }

  // void loop() {
  //   val %= 1024;
  //   Particle.publish("Servo-Test", String(val), PRIVATE);
  //   analogWrite(A1, val++, 180);
  //   delay(100);
  // }
#pragma endregion } Servor test

Credits

Luis Vega

Luis Vega

1 project • 0 followers

Comments

Add projectSign up / Login