SDS011 – Feinstaubsensor

Mit dem Modul SDS011 kann der Feinstaub in der Luft per Particulate Matter (PM) „gezählt“ werden. Es werden Partikelgrößen in den Bereichen PM 2.5 und PM 10 registriert.

Die Kommunikation mit dem Arduino geht per Serieller Verbindung. Der Sensor kann per HEX Befehl gesteuert oder Schlafen gelegt werden. Dies ist auch bei Einsatz als „Messsonde“ auch sinnvoll da die Lebensdauer der Laserdiode auf 8000 h geschätzt wird. Mehr Infos gibt es Datenblatt am Ende des Beitrages.

Ein einfacher Arduino Sketch zum auslesen der Daten sollte als Basis für weitere Entwicklungen ausreichend sein. Hierfür bietet sich die Library von Paweł Kołodziejczyk an die hier zu finden ist.



Nachfolgend eine Ausgabe im Arduino Seriellen Monitor.

 
#include "SdsDustSensor.h"
 
int rxPin = 6;
int txPin = 7;
SdsDustSensor sds(rxPin, txPin);
 
void setup() {
  Serial.begin(9600);
  sds.begin();
 
  Serial.println(sds.queryFirmwareVersion().toString()); // prints firmware version
  Serial.println(sds.setActiveReportingMode().toString()); // ensures sensor is in 'active' reporting mode
  Serial.println(sds.setCustomWorkingPeriod(10).toString()); // sensor sends data every 3 minutes
}
 
void loop() {
  PmResult pm = sds.readPm();
  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 {
    // notice that loop delay is set to 5s (sensor sends data every 3 minutes) and some reads are not available
    Serial.print("Could not read values from sensor, reason: ");
    Serial.println(pm.statusToString());
  }
 
  delay(5000);
}

Nachfolgend noch das Datenblatt von Nova Fitness Co., Ltd..

Wemos D1 ESP8266 Board als Webserver

Mit dem nachfolgendem Sketch betreiben Sie den Wemos DA ESP8266 im WiFi als Webserver.

In dem Sketch wird eine feste IP vergeben. Ich finde das immer angenehmer wie dynamische Vergabe.

    #include <ESP8266WiFi.h>
 
const char* ssid = "DEINE_SSID";
const char* password = "DEIN_PASSWORT";
 
int ledPin = D5;
WiFiServer server(80);
 
void setup() {
  Serial.begin(19200);
  delay(10);
 
 
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
 
  // Connect to WiFi network
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
 
WiFi.begin(ssid, password);
 
  IPAddress ip(192, 168, 187, 52); // Feste IP vergeben
  IPAddress gateway(192, 168, 1, 1);
  IPAddress subnet(255, 255, 0, 0);
  IPAddress dns(192, 168, 1, 1);
  WiFi.config(ip, dns, gateway, subnet);
 
 
 
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
 
  // Start the server
  server.begin();
  Serial.println("Server started");
 
  // Print the IP address
  Serial.print("Use this URL : ");
  Serial.print("http://");
  Serial.print(WiFi.localIP());
  Serial.println("/");
 
}
 
void loop() {
  // Check if a client has connected
  WiFiClient client = server.available();
  if (!client) {
    return;
  }
 
  // Wait until the client sends some data
  Serial.println("new client");
  while(!client.available()){
    delay(1);
  }
 
  // Read the first line of the request
  String request = client.readStringUntil('\r');
  Serial.println(request);
  client.flush();
 
  // Match the request
 
  int value = LOW;
  if (request.indexOf("/LED=ON") != -1) {
    digitalWrite(ledPin, HIGH);
    value = HIGH;
  } 
  if (request.indexOf("/LED=OFF") != -1){
    digitalWrite(ledPin, LOW);
    value = LOW;
  }
 
 
 
  // Return the response
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: text/html");
  client.println(""); //  do not forget this one
  client.println("<!DOCTYPE HTML>");
  client.println("<html>");
 
  client.print("Led pin is now: ");
 
  if(value == HIGH) {
    client.print("On");  
  } else {
    client.print("Off");
  }
  client.println("<br><br>");
  client.println("Click <a href=\"/LED=ON\">here</a> turn the LED on pin 5 ON<br>");
  client.println("Click <a href=\"/LED=OFF\">here</a> turn the LED on pin 5 OFF<br>");
  client.println("</html>");
 
  delay(1);
  Serial.println("Client disconnected");
  Serial.println("");
 
}

Analogeingang lesen mit einem Drucksensor

Mit diesem einfachen Aufbau lesen wir mit dem Seriellen Monitor einen Drucksensor an einem Analogen Eingang des Arduino Uno aus

int analogPin = 0;  // AnaogPin deklarieren  
                       
int val = 0;           

void setup()
{
  //Serielle Uebertragung 
  Serial.begin(9600);         
}

void loop()
{
  // AnalogPIN auslesen
  val = analogRead(analogPin);
  // Wert des AnalogPin ausgeben  
  Serial.println(val);             
  delay(150);
}

Unser Shop

Ein Arduino sendet PUSH Nachrichten

Wenn man einem Arduino ein Ethernet Shield spendiert ist dieser im Netzwerk ansprechbar. Aber außer ein par Sensoren zu betreiben und LEDs an und aus zu schalten kann er auch PUSH Meldungen senden.



Als erstes benötigt man einen Account bei einem PUSH Dienst. In meinem Beispiel verwende ich den Dienst pushingbox.com.

Weil es den Rahmen hier sprengen würde die vielen Möglichkeiten des Dienstes zu erklären hier ein kleines Video für den „Erstkontakt“.

Nun kann man im Bereich API sich den Sketch für einen Arduino ansehen.

https://www.pushingbox.com/api.php

Hier nun mal der Sketch von pushingbox.com (Stand 2018)

////
//
// General code from http://www.pushingbox.com for Arduino + Ethernet Shield (official) v1.2
//
////

#include <SPI.h>
#include <Ethernet.h>

  /////////////////
 // MODIFY HERE //
/////////////////
byte mac[] = { 0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x19 };   // Be sure this address is unique in your network

//Your secret DevID from PushingBox.com. You can use multiple DevID  on multiple Pin if you want
char DEVID1[] = "Your_DevID_Here";        //Scenario : "The mailbox is open"

//Numeric Pin where you connect your switch
uint8_t pinDevid1 = 3; // Example : the mailbox switch is connect to the Pin 3

// Debug mode
boolean DEBUG = true;
  //////////////
 //   End    //
//////////////


char serverName[] = "api.pushingbox.com";
boolean pinDevid1State = false;                // Save the last state of the Pin for DEVID1
boolean lastConnected = false;                 // State of the connection last time through the main loop


// Initialize the Ethernet client library
// with the IP address and port of the server 
// that you want to connect to (port 80 is default for HTTP):
EthernetClient client;

void setup() {
  Serial.begin(9600);
  pinMode(pinDevid1, INPUT);
  
  // start the Ethernet connection:
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    // no point in carrying on, so do nothing forevermore:
    while(true);
  }
  else{
    Serial.println("Ethernet ready");
    // print the Ethernet board/shield's IP address:
    Serial.print("My IP address: ");
    Serial.println(Ethernet.localIP());
  }
  // give the Ethernet shield a second to initialize:
  delay(1000);
}

void loop()
{
      ////
      // Listening for the pinDevid1 state
      ////
      if (digitalRead(pinDevid1) == HIGH && pinDevid1State == false) // switch on pinDevid1 is ON 
      {
        if(DEBUG){Serial.println("pinDevid1 is HIGH");}
        pinDevid1State = true;
        //Sending request to PushingBox when the pin is HIGH
        sendToPushingBox(DEVID1);
      }
       if (digitalRead(pinDevid1) == LOW && pinDevid1State == true) // switch on pinDevid1 is OFF
      {
        if(DEBUG){Serial.println("pinDevid1 is LOW");}
        pinDevid1State = false;
        //Sending request to PushingBox when the pin is LOW
        //sendToPushingBox(DEVID1);    //Here you can run an other scenario by creating a DEVID2 variable
      }
      
      
      //DEBUG part
      // this write the respons from PushingBox Server.
      // You should see a "200 OK"
      if (client.available()) {
        char c = client.read();
        if(DEBUG){Serial.print(c);}
      }
      
      // if there's no net connection, but there was one last time
      // through the loop, then stop the client:
      if (!client.connected() && lastConnected) {
        if(DEBUG){Serial.println();}
        if(DEBUG){Serial.println("disconnecting.");}
        client.stop();
      }
      lastConnected = client.connected();
}


//Function for sending the request to PushingBox
void sendToPushingBox(char devid[]){
  client.stop();
  if(DEBUG){Serial.println("connecting...");}

  if (client.connect(serverName, 80)) {
    if(DEBUG){Serial.println("connected");}

    if(DEBUG){Serial.println("sendind request");}
    client.print("GET /pushingbox?devid=");
    client.print(devid);
    client.println(" HTTP/1.1");
    client.print("Host: ");
    client.println(serverName);
    client.println("User-Agent: Arduino");
    client.println();
  } 
  else {
    if(DEBUG){Serial.println("connection failed");}
  }
}

So, nun nur noch deine „Your_DevID_Here“ ändern. Diese kannst du unter „My Service“ neu anlegen.

In meinem Beispiel twittert nun der Arduino bei einem Ereigniss am PIN3.
Natürlich kann man auch einen entsprechenden Dienst aussuchen um eine PUSH Nachricht auf dein Handy zu bekommen.

So einfach ….

Servos mit dem Raspberry ansteuern

Einen Servo an einem Raspberry zu betreiben ist mit der richtigen Bibliothek einfacher als man denkt. Das Stichwort dafuer ist „ServoBlaster“.

ServoBlaster installieren

mkdir -p ~/servoblaster/ 
cd ~/servoblaster/
git clone https://github.com/richardghirst/PiBits
mv PiBits/ServoBlaster/ . && rm -rf PiBits
cd ServoBlaster/user
sudo make install

Mehr ist es nicht. Jetzt noch den Servo mit den GPIO’s des Raspberry verbiden.

  • 5V (Plus)
  • GND (Minus)
  • PIN17 die Datenleitung

Es ist zu empfehlen den Servo direkt an die 5V Stromquelle anzuschliessen. Der Betriebsstrom des Servos kann unter umstaenden Schaeden im Raspberry hervorrufen.

Nachfolgen noch eine Uebersicht welcher P1 Header welchen GPIO anspricht.

 Servo number    GPIO number   Pin in P1 header
          0               4             P1-7
          1              17             P1-11
          2              18             P1-12
          3             21/27           P1-13
          4              22             P1-15
          5              23             P1-16
          6              24             P1-18
          7              25             P1-22

Nun ist es aber an der Zeit fuer den ersten Test in der shell .

echo 1=90 > /dev/servoblaster
sleep 1
echo 1=150 > /dev/servoblaster
sleep 1
echo 1=250 > /dev/servoblaster

Hierbei ist die 1 nach dem echo Befehl der Servo aus der obigen Liste. Also in unserem Beispiel bedeutet es das durch echo 1=90 der Servo an GPIO 17 auf 90 Grad gestellt wird.

Temperatur messen mit dem DS18B20

Besteht mal der Bedarf an einer Temperatur Messung ist der DS18B20 ideal dafuer geeignet. 

DS18B20 Wasserdicht

Gemessen wird mit einem One Wire Bus. Durch diesen Bus ist es moeglich an einem Daten-Pin des Arduino mehrer Messfuehler anzuschliessen. Denn Pins einsparen ist immer von Vorteil.

Beschaltung des DS18B20

Und nun noch der entsprechende Sketch.

#include <OneWire.h>

// OneWire DS18S20, DS18B20, DS1822 Temperature Example
//
// http://www.pjrc.com/teensy/td_libs_OneWire.html
//
// The DallasTemperature library can do all this work for you!
// http://milesburton.com/Dallas_Temperature_Control_Library

OneWire  ds(2);  // on pin 10 (a 4.7K resistor is necessary)

void setup(void) {
  Serial.begin(9600);
}

void loop(void) {
  byte i;
  byte present = 0;
  byte type_s;
  byte data[12];
  byte addr[8];
  float celsius, fahrenheit;
  
  if ( !ds.search(addr)) {
    Serial.println("No more addresses.");
    Serial.println();
    ds.reset_search();
    delay(250);
    return;
  }
  
  Serial.print("ROM =");
  for( i = 0; i < 8; i++) {
    Serial.write(' ');
    Serial.print(addr[i], HEX);
  }

  if (OneWire::crc8(addr, 7) != addr[7]) {
      Serial.println("CRC is not valid!");
      return;
  }
  Serial.println();
 
  // the first ROM byte indicates which chip
  switch (addr[0]) {
    case 0x10:
      Serial.println("  Chip = DS18S20");  // or old DS1820
      type_s = 1;
      break;
    case 0x28:
      Serial.println("  Chip = DS18B20");
      type_s = 0;
      break;
    case 0x22:
      Serial.println("  Chip = DS1822");
      type_s = 0;
      break;
    default:
      Serial.println("Device is not a DS18x20 family device.");
      return;
  } 

  ds.reset();
  ds.select(addr);
  ds.write(0x44, 1);        // start conversion, with parasite power on at the end
  
  delay(1000);   

  present = ds.reset();
  ds.select(addr);    
  ds.write(0xBE);         // Read Scratchpad

  Serial.print("  Data = ");
  Serial.print(present, HEX);
  Serial.print(" ");
  for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds.read();
    Serial.print(data[i], HEX);
    Serial.print(" ");
  }
  Serial.print(" CRC=");
  Serial.print(OneWire::crc8(data, 8), HEX);
  Serial.println();

  int16_t raw = (data[1] << 8) | data[0];
  if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) {
      // "count remain" gives full 12 bit resolution
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  } else {
    byte cfg = (data[4] & 0x60);
    // at lower res, the low bits are undefined, so let's zero them
    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
    //// default is 12 bit resolution, 750 ms conversion time
  }
  celsius = (float)raw / 16.0;
  fahrenheit = celsius * 1.8 + 32.0;
  Serial.print("  Temperature = ");
  Serial.print(celsius);
  Serial.print(" Celsius, ");
  Serial.print(fahrenheit);
  Serial.println(" Fahrenheit");
}