Rename config.h Example

.vscode/extensions.json

@@ -1,7 +1,10 @@
-{
+{
-    // See http://go.microsoft.com/fwlink/?LinkId=827846
+    // See http://go.microsoft.com/fwlink/?LinkId=827846
-    // for the documentation about the extensions.json format
+    // for the documentation about the extensions.json format
-    "recommendations": [
+    "recommendations": [
-        "platformio.platformio-ide"
+        "platformio.platformio-ide"
-    ]
+    ],
-}
+    "unwantedRecommendations": [
+        "ms-vscode.cpptools-extension-pack"
+    ]
+}

include/debug.h

@@ -8,9 +8,11 @@ DebugUtils.h - Simple debugging utilities.
 #ifdef DEBUG
   #define DEBUG_PRINT(...) Serial.print(__VA_ARGS__); Serial.flush();
   #define DEBUG_PRINTLN(...) Serial.println(__VA_ARGS__); Serial.flush();
+  #define DEBUG_PRINTARR(...) for (uint8_t i=0; i<(sizeof(__VA_ARGS__)/sizeof(__VA_ARGS__[0])); i++) { Serial.print(__VA_ARGS__[i], HEX); Serial.print(" ");}; Serial.flush();
 #else
   #define DEBUG_PRINT(...)
   #define DEBUG_PRINTLN(...)
+  #define DEBUG_PRINTARR(...)
 #endif
 
-#endif
+#endif

lib/HM330x/HM330x.cpp

@@ -46,8 +46,11 @@ void HM330x::initialize(void) {
   }
 
   // Wait for Sensor to get Ready
-  DEBUG_PRINTLN("HM330x::initialize Waiting for Sensor Startup");
+  if (sleep_pin == 0) {
-  delay(30000);
+    DEBUG_PRINTLN("HM330x::initialize Waiting for Sensor Startup");
+    delay(30000);
+  }
+
 
   DEBUG_PRINTLN("HM330x::initialize Trying to send Select");
   // Send select command
@@ -65,46 +68,58 @@ void HM330x::initialize(void) {
 // Read Data From Sensor and Put Them Into the Payload Array
 uint8_t HM330x::getSensorData(char *payload, uint8_t startbyte) {
   uint8_t data[HM330x_DATA_LEN] = {0};
-  uint16_t value = 0;
+  uint16_t values[3] = { 0xEEEE, 0xEEEE, 0xEEEE };
 
   DEBUG_PRINTLN("HM330x::getSensorData");
   
   // Enable Sensor and Wait for it to Settle
   if (sleep_pin > 0) {
     digitalWrite(sleep_pin, HIGH);
+    DEBUG_PRINTLN("HM330x::getSensorData Waiting for Stable Values after Sleep");
     delay(30000);
+    sendCmd(HM330x_SELECT);
   }
 
   // Initialize Payload with 0s
   for (uint8_t i=startbyte; i < startbyte+6; i++)
     payload[i] = 0xFF;
 
-  // Get Data from the Sensors
+  bool    dataok = false;
-  Wire.requestFrom(HM330x_ADDR, HM330x_DATA_LEN);
+  uint8_t tries  = 5;
-  if (Wire.available()) {
-    DEBUG_PRINT("HM330x::getSensorData reading I2C:")
-    for (uint8_t i = 0; i<HM330x_DATA_LEN; i++){
-      data[i] = Wire.read();
-      DEBUG_PRINT(" 0x");
-      DEBUG_PRINT(data[i], HEX);
-    }
-    DEBUG_PRINTLN("");
 
-    if (calcSum(data) == data[HM330x_DATA_LEN-1]) {
+  while (!dataok && tries > 0) {
-      for (uint8_t pos = 5; pos<8; pos++) {
+    DEBUG_PRINT("HM330x::getSensorData reading I2C Try ");
-        value = bytesToUint16(data, pos);
+    DEBUG_PRINTLN(6-tries);
-        uint16ToPayload(value, payload, startbyte);
+    // Get Data from the Sensors
-        startbyte += 2;
+    Wire.requestFrom(HM330x_ADDR, HM330x_DATA_LEN);
+    if (Wire.available()) {
+      DEBUG_PRINT("HM330x::getSensorData I2C data: 0x")
+      for (uint8_t i = 0; i<HM330x_DATA_LEN; i++){
+        data[i] = Wire.read();
+        DEBUG_PRINT(data[i], HEX);
+        DEBUG_PRINT(" ");
       }
-      if (sleep_pin > 0) {
+      DEBUG_PRINTLN("");
-        digitalWrite(sleep_pin, LOW);
+
+      if (calcSum(data) == data[HM330x_DATA_LEN-1]) {
+        for (uint8_t pos = 5; pos<8; pos++) {
+          values[pos-5]= bytesToUint16(data, pos);
+        }
+        dataok = true;
+      } else {
+        DEBUG_PRINTLN("HM330x::getSensorData Checksum Error")
+        delay(2000);
+        tries--;
       }
-      return startbyte;
     } else {
-      for (uint8_t i=startbyte; i < startbyte+6; i++)
+      DEBUG_PRINTLN("HM330x::getSensorData I2C Not Ready")
-        payload[i] = 0xEE;
+      delay(2000);
+      tries--;
     }
   }
+  uint16ToPayload(values[0], payload, startbyte);
+  uint16ToPayload(values[1], payload, startbyte+2);
+  uint16ToPayload(values[2], payload, startbyte+4);
   if (sleep_pin > 0) {
     digitalWrite(sleep_pin, LOW);
   }

lib/SPS30/SPS30.cpp

@@ -27,69 +27,90 @@
 #include <Arduino.h>
 #include "SPS30.h"
 
-SPS30::SPS30() {
+// Read Measurements from Sensor and put them into the Paylaod
-}
-
-
 uint8_t SPS30::getSensorData(char *payload, uint8_t startbyte) {
-  uint8_t data[30];
+  // Buffer to hold the raw I2C Return
-  for (uint8_t i = 0; i < 30; i++)
+  uint8_t  data[30]; 
-    data[i] = 0xFF;
+  // Array with calculated Values.
-  
+  // Predefined with 0xEEEE to recognize Read Errors in the Payload
-  uint16_t massPM1, massPM25, massPM4, massPM10, typPM;
+  uint16_t values[5] = {0xEEEE, 0xEEEE, 0xEEEE, 0xEEEE, 0xEEEE};
+
+  // Wakeup Sensor from Sleep
+  DEBUG_PRINTLN("SPS30::getSensorData - Wake Up Sensor");
+  Wire.beginTransmission(SPS30_I2C_ADDRESS);
+  Wire.endTransmission();
+  delay(50);
+  write(SPS30_WAKEUP);
+  delay(50);
 
   // Start Measuring, Integer Output
+  DEBUG_PRINTLN("SPS30::getSensorData - StartMeasurement");
   write(SPS30_START_MEASUREMENT, 0x0500);
-  // Wait for Stable Values (max 30s according to datasheet)
+  // Wait for Stable Values
-  delay(30000);
+  DEBUG_PRINTLN("SPS30::getSensorData - WaitForStabilize");
+  delay(SPS30_STABILIZE_TIME);
 
-  if (hasData()) {
+  bool    dataok = false;
-    write(SPS30_READ_MEASUREMENT);
+  uint8_t tries = 5;
-    Wire.requestFrom(SPS30_I2C_ADDRESS, 30);
-    if (Wire.available() != 0) {
-      for (uint8_t i = 0; i < 30; i++)
-        data[i] = 0xFE;
-      
-      Wire.readBytes(data, 30);
 
-      // DEBUG OUTPUT
+  // Retry up to 5 times to get a Valid Measurement from the Sensor
-      DEBUG_PRINT("SPS30 I2C DATA: ")
+  while (!dataok && tries > 0) {
-      for (uint8_t i = 0; i < 30; i++) {
+    DEBUG_PRINT("SPS30::getSensorData - Reading Sensor Data, Try ");
-        DEBUG_PRINT("0x");
+    DEBUG_PRINTLN(6-tries);
-        DEBUG_PRINT (data[i]);
+    if (hasData()) {
-        DEBUG_PRINT(", ");
+      write(SPS30_READ_MEASUREMENT);
-      }
+      Wire.requestFrom(SPS30_I2C_ADDRESS, 30);
+      if (Wire.available() != 0) { 
+        Wire.readBytes(data, 30);
+
+        DEBUG_PRINT("SPS30::getSensorData - I2C-Data: ");
+        DEBUG_PRINTARR(data);
+        DEBUG_PRINTLN("");
+
+        // Get Values for PM1.0, 2.5, 4 and 10 in Order
+        dataok = true;
+        for (uint8_t i=0; i<4; i++)
+          if (data[(i*3)+2] == calcCRC(data+(i*3), 2)) {
+            values[i] = data[i*3] << 8 | data[(i*3)+1]; // Create uint16_t from Bytes
+          } else {
+            dataok = false; // Set false on Checksum Error
+          }
         
-      DEBUG_PRINTLN("");
+        // Get Typical Particle size
-
+        if (data[29] == calcCRC(data+27, 2)) {
-      // PM1.0
+          values[4] = data[27] << 8 | data[28]; // Create uint16_t from Bytes
-      if (data[2] == calcCRC(data, 2))
+        } else {
-        massPM1 = data[0] << 8 | data[1];
+          dataok = false; // Set false on Checksum Error
-
+        }
-      // PM2.5
+        
-      if (data[5] == calcCRC(data+3, 2))
+        if (!dataok) {
-        massPM25 = data[3] << 8 | data[4];
+          // If a Checksum error occured
-      
+          DEBUG_PRINTLN("SPS30::getSensorData - CheckSum Error");
-      // PM4
+          tries--;
-      if (data[8] == calcCRC(data+6, 2))
+          delay(2000);
-        massPM4 = data[6] << 8 | data[7];
+        }
-      
+      } else {
-      // PM10
+        // No I2C Data Available
-      if (data[11] == calcCRC(data+9, 2))
+        DEBUG_PRINTLN("SPS30::getSensorData - Error, no I2C Data available");
-        massPM10 = data[9] << 8 | data[10];
+        tries--;
-      
+        delay(2000);
-      // Typical Size
+      }
-      if (data[29] == calcCRC(data+27, 2))
+    } else {
-        typPM = data[27] << 8 | data[28];
+      // No Data Ready from Sensor
+      DEBUG_PRINTLN("SPS30::getSensorData - Error, Sensor Data not Ready");
+      tries--;
+      delay(2000);
     }
   }
+  DEBUG_PRINTLN("SPS30::getSensorData - StopMeasurement");
   write(SPS30_STOP_MEASUREMENT);
-
+  delay(50);
-  uint16ToPayload(massPM1, payload, startbyte);
+  DEBUG_PRINTLN("SPS30::getSensorData - SensorSleep");
-  uint16ToPayload(massPM25, payload, startbyte+2);
+  write(SPS30_SLEEP);
-  uint16ToPayload(massPM4, payload, startbyte+4);
+  
-  uint16ToPayload(massPM10, payload, startbyte+6);
+  // Put the Values into the Payload Array
-  uint16ToPayload(typPM, payload, startbyte+8);
+  for (uint8_t i=0; i<5; i++)
+    uint16ToPayload(values[i], payload, startbyte+(i*2));
 }
 
 // Check if Sensor has Data
@@ -114,6 +135,7 @@ uint16_t SPS30::readReg(uint16_t regAddr) {
   return(0);
 }
 
+// Write a 16 Bit Command without Parameters
 bool SPS30::write(uint16_t cmd) {
   Wire.beginTransmission(SPS30_I2C_ADDRESS);
   Wire.write(cmd >> 8);
@@ -123,6 +145,7 @@ bool SPS30::write(uint16_t cmd) {
   return(true);
 }
 
+// Write a 16Bit Command with 16Bit Parameters
 bool SPS30::write(uint16_t cmd, uint16_t arg){
   uint8_t crcdata[2];
   crcdata[0] = arg >> 8;

lib/SPS30/SPS30.h

@@ -32,18 +32,21 @@
 #include "../../include/debug.h"
 
 // I2C Address
-#define SPS30_I2C_ADDRESS 0x69
+#define SPS30_I2C_ADDRESS    0x69
+#define SPS30_STABILIZE_TIME 30000
 
 // I2C Commands and Registers
-#define SPS30_START_MEASUREMENT 0x0010
+#define SPS30_START_MEASUREMENT   0x0010
-#define SPS30_STOP_MEASUREMENT 0x0104
+#define SPS30_STOP_MEASUREMENT    0x0104
-#define SPS30_GET_DATA_READY 0x0202
+#define SPS30_GET_DATA_READY      0x0202
-#define SPS30_READ_MEASUREMENT 0x0300
+#define SPS30_READ_MEASUREMENT    0x0300
 #define SPS30_AUTO_CLEAN_INTERVAL 0x8004
-#define SPS30_START_FAN_CLEANING 0x5607
+#define SPS30_START_FAN_CLEANING  0x5607
-#define SPS30_READ_ARTICLE_CODE 0xD025
+#define SPS30_READ_ARTICLE_CODE   0xD025
-#define SPS30_READ_SERIAL_NUMBER 0xD033
+#define SPS30_READ_SERIAL_NUMBER  0xD033
-#define SPS30_DEVICE_RESET 0xD304
+#define SPS30_DEVICE_RESET        0xD304
+#define SPS30_SLEEP               0x1001
+#define SPS30_WAKEUP              0x1103
 
 class SPS30 : public AttSensor {
   private:
@@ -54,11 +57,11 @@ class SPS30 : public AttSensor {
     bool write(uint16_t cmd, uint16_t arg);
   
   public:
-    SPS30();
+    SPS30() {};
-    uint8_t getSensorData(char *payload, uint8_t startbyte);
+    uint8_t getSensorData(char *payload, uint8_t startbyte) override;
-    void calibrate(void) {};
+    void calibrate(void) override {};
-    void initialize(void) {};
+    void initialize(void) override {} ;
-    uint8_t numBytes(void) { return 10; };
+    uint8_t numBytes(void) override { return 10; };
 };
 
 #endif