Merge pull request #4 from lewapek/feature/hardwareSerial

Adding support for HardwareSerial [fixes #3]

Author: lewapek

README.md

@@ -1,6 +1,7 @@
 # Nova Fitness SDS dust sensors arduino library
 Supports Nova Fitness SDS011 however should also work for other Nova Fitness SDS sensors as well.
 This library attempts to provide easy-to-use abstraction over [Laser Dust Sensor Control Protocol V1.3](https://cdn.sparkfun.com/assets/parts/1/2/2/7/5/Laser_Dust_Sensor_Control_Protocol_V1.3.pdf).
+Each response coming from sensor is validated whether it has correct head, command id, checksum and tail.
 
 ## Quickstart
 ```
@@ -37,11 +38,36 @@ void loop() {
   delay(500);
 }
 ```
-
 For more examples see [examples](examples/) folder.
 
+## Initilization
+Communication with sensor can be handled by SoftwareSerial or HardwareSerial. You can pass SoftwareSerial or HardwareSerial directly to the constructor or provide rx & tx pins (library will use SoftwareSerial then).
+
+### Using tx and rx pins
+Communication will be implicitly handled by SoftwareSerial.
+```
+int rxPin = D1;
+int txPin = D2;
+SdsDustSensor sds(rxPin, txPin);
+sds.begin(); // you can pass custom baud rate as parameter (9600 by default)
+```
+
+### Explicit SoftwareSerial
+```
+int rxPin = D1;
+int txPin = D2;
+SoftwareSerial softwareSerial(rxPin, txPin);
+SdsDustSensor sds(softwareSerial);
+sds.begin(); // you can pass custom baud rate as parameter (9600 by default)
+```
+
+### Explicit HardwareSerial
+```
+SdsDustSensor sds(Serial1); // passing HardwareSerial as parameter
+sds.begin(); // you can pass custom baud rate as parameter (9600 by default)
+```
+
 ## Supported operations
-Each response coming from sensor is validated whether it has correct head, command id, checksum and tail. Communication with sensor is handled via SoftwareSerial.
 All operations listed in [Laser Dust Sensor Control Protocol V1.3](https://cdn.sparkfun.com/assets/parts/1/2/2/7/5/Laser_Dust_Sensor_Control_Protocol_V1.3.pdf) are fully supported. They are listed below:
 * read PM2.5, PM10 values (reads data from software serial, does not write anything to the serial, all other operations write date to the sensor and expect response - sensor should be set to "active" reporting mode),
 * query PM2.5, PM10 values (in opposite to above, this one sends command to sensor and it responds with PM2.5 and PM10 values - sensor should be set to "query" reporting mode),
@@ -59,12 +85,6 @@ All operations listed in [Laser Dust Sensor Control Protocol V1.3](https://cdn.s
 
 Additionally you can read device id from every sensor response.
 
-### Setting up the sensor
-```
-SdsDustSensor sds(rxPin, txPin);
-sds.begin();
-```
-
 ### Reading PM2.5 and PM10 values
 The following function (readPm()) checks whether there is available data sent from sensor, it does not send any request to sensor so it has to be in 'active' reporting mode.
 ```

examples/hardwareSerial/hardwareSerial.ino

@@ -0,0 +1,39 @@
+#include "SdsDustSensor.h"
+
+// tested on Arduino Leonardo with Serial1
+SdsDustSensor sds(Serial1); // passing HardwareSerial& as parameter
+
+void setup() {
+  Serial.begin(9600);
+  sds.begin(); // this line will begin Serial1 with given baud rate (9600 by default)
+
+  Serial.println(sds.queryFirmwareVersion().toString()); // prints firmware version
+  Serial.println(sds.setQueryReportingMode().toString()); // ensures sensor is in 'query' reporting mode
+}
+
+void loop() {
+  sds.wakeup();
+  delay(30000); // working 30 seconds
+
+  PmResult pm = sds.queryPm();
+  if (pm.isOk()) {
+    Serial.print("PM2.5 = ");
+    Serial.print(pm.pm25);
+    Serial.print(", PM10 = ");
+    Serial.println(pm.pm10);
+
+    // if you want to just print the measured values, you can use toString() method as well
+    Serial.println(pm.toString());
+  } else {
+    Serial.print("Could not read values from sensor, reason: ");
+    Serial.println(pm.statusToString());
+  }
+
+  WorkingStateResult state = sds.sleep();
+  if (state.isWorking()) {
+    Serial.println("Problem with sleeping the sensor.");
+  } else {
+    Serial.println("Sensor is sleeping");
+    delay(60000); // wait 1 minute
+  }
+}

src/SdsDustSensor.cpp

@@ -1,9 +1,9 @@
 #include "SdsDustSensor.h"
 
 void SdsDustSensor::write(const Command &command) {
-  sdsSerial->flush();
+  sdsStream->flush();
   for (int i = 0; i < Command::length; ++i) {
-    sdsSerial->write(command.bytes[i]);
+    sdsStream->write(command.bytes[i]);
     #ifdef __DEBUG_SDS_DUST_SENSOR__
     Serial.print("|");
     Serial.print(command.bytes[i], HEX);
@@ -19,9 +19,9 @@ Status SdsDustSensor::readIntoBytes(byte responseId) {
   int checksum = 0;
   int readBytesQuantity = 0;
 
-  while ((sdsSerial->available() > 0) &&
-        (sdsSerial->available() >= Result::lenght - readBytesQuantity)) {
-    byte readByte = sdsSerial->read();
+  while ((sdsStream->available() > 0) &&
+        (sdsStream->available() >= Result::lenght - readBytesQuantity)) {
+    byte readByte = sdsStream->read();
     response[readBytesQuantity] = readByte;
 
     #ifdef __DEBUG_SDS_DUST_SENSOR__

src/SdsDustSensor.h

@@ -28,24 +28,36 @@
 
 #include "SdsDustSensorCommands.h"
 #include "SdsDustSensorResults.h"
-#include <SoftwareSerial.h>
+#include "Serials.h"
 
 // #define __DEBUG_SDS_DUST_SENSOR__
 
 class SdsDustSensor {
 public:
-  SdsDustSensor(int pinRx, int pinTx, int baudRate = 9600):
-    sdsSerial(new SoftwareSerial(pinRx, pinTx)),
-    baudRate(baudRate) {}
+  SdsDustSensor(int pinRx, int pinTx):
+    abstractSerial(new Serials::InternalSoftware(pinRx, pinTx)) {
+      sdsStream = abstractSerial->getStream();
+    }
+
+  SdsDustSensor(SoftwareSerial &softwareSerial):
+    abstractSerial(new Serials::Software(softwareSerial)) {
+      sdsStream = abstractSerial->getStream();
+    }
+
+  SdsDustSensor(HardwareSerial &hardwareSerial):
+    abstractSerial(new Serials::Hardware(hardwareSerial)) {
+      sdsStream = abstractSerial->getStream();
+    }
 
   ~SdsDustSensor() {
-    if (sdsSerial != NULL) {
-      delete sdsSerial;
+    if (abstractSerial != NULL) {
+      abstractSerial->release();
+      delete abstractSerial;
     }
   }
 
-  void begin() {
-    sdsSerial->begin(baudRate);
+  void begin(int baudRate = 9600) {
+    abstractSerial->begin(baudRate);
   }
 
   byte *getLastResponse() {
@@ -131,8 +143,8 @@ class SdsDustSensor {
 
 private:
   byte response[Result::lenght];
-  int baudRate;
-  SoftwareSerial *sdsSerial = NULL;
+  Stream *sdsStream = NULL;
+  Serials::AbstractSerial *abstractSerial;
 };
 
 #endif // __SDS_DUST_SENSOR_H__

src/Serials.h

@@ -0,0 +1,55 @@
+#ifndef __SDS_ABSTRACT_SERIAL_H__
+#define __SDS_ABSTRACT_SERIAL_H__
+
+#include <SoftwareSerial.h>
+#include <HardwareSerial.h>
+
+namespace Serials {
+
+  struct AbstractSerial {
+    virtual void begin(int baudRate) ;
+    virtual Stream *getStream();
+    virtual void release() {
+      // do nothing by default
+    }
+  };
+
+  struct Hardware: public AbstractSerial {
+    Hardware(HardwareSerial &serial): serial(serial) {}
+
+    void begin(int baudRate) {
+      serial.begin(baudRate);
+    }
+
+    Stream *getStream() {
+      return &serial;
+    }
+
+    HardwareSerial &serial;
+  };
+
+  struct Software: public AbstractSerial {
+    Software(SoftwareSerial &serial): serial(serial) {}
+
+    void begin(int baudRate) {
+      serial.begin(baudRate);
+    }
+
+    Stream *getStream() {
+      return &serial;
+    }
+
+    SoftwareSerial &serial;
+  };
+
+  struct InternalSoftware: public Software {
+    InternalSoftware(const int &pinRx, const int &pinTx): Software(*(new SoftwareSerial(pinRx, pinTx))) {}
+
+    void release() {
+      delete &serial;
+    }
+  };
+
+}
+
+#endif // __SDS_ABSTRACT_SERIAL_H__