Integrated Practical Applications

#include <DHT.h>

#define DHT_PIN  7
#define DHT_TYPE DHT11

DHT sensor(DHT_PIN, DHT_TYPE);

unsigned long lastReading = 0;
const unsigned long INTERVAL = 2000;   // respects the minimum interval

float tMin = 999, tMax = -999;         // extreme values since power-on

void setup() {
  Serial.begin(9600);
  sensor.begin();
  Serial.println("Weather station started");
}

void loop() {
  if (millis() - lastReading < INTERVAL) return;   // non-blocking timing
  lastReading = millis();

  float humidity    = sensor.readHumidity();
  float temperature = sensor.readTemperature();

  if (isnan(humidity) || isnan(temperature)) {     // MANDATORY check
    Serial.println("Error reading the sensor!");
    return;
  }

  if (temperature < tMin) tMin = temperature;
  if (temperature > tMax) tMax = temperature;

  float heatIndex = sensor.computeHeatIndex(temperature, humidity, false);

  Serial.print("T = ");        Serial.print(temperature, 1);
  Serial.print(" C   RH = ");  Serial.print(humidity, 1);
  Serial.print(" %   feels like = "); Serial.print(heatIndex, 1);
  Serial.print(" C   [min ");  Serial.print(tMin, 1);
  Serial.print(" / max ");     Serial.print(tMax, 1);
  Serial.println("]");
}

const uint8_t IN1 = 4, IN2 = 5, ENA = 9;   // ENA must be a PWM pin
const uint8_t POT_PIN = A0;
const uint8_t MIN_DUTY = 60;               // below this the motor does not start

void setDirection(bool forward) {
  digitalWrite(IN1, forward ? HIGH : LOW);
  digitalWrite(IN2, forward ? LOW  : HIGH);
}

void stopMotor() {
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);
  analogWrite(ENA, 0);
}

void setup() {
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(ENA, OUTPUT);
  Serial.begin(9600);
  stopMotor();
}

void loop() {
  uint16_t raw = analogRead(POT_PIN);

  // dead zone in the middle: below 490 backward, above 530 forward, in between stopped
  if (raw < 490) {
    setDirection(false);
    uint8_t duty = map(raw, 489, 0, MIN_DUTY, 255);
    analogWrite(ENA, duty);
    Serial.print("BACKWARD duty="); Serial.println(duty);
  }
  else if (raw > 530) {
    setDirection(true);
    uint8_t duty = map(raw, 531, 1023, MIN_DUTY, 255);
    analogWrite(ENA, duty);
    Serial.print("FORWARD  duty="); Serial.println(duty);
  }
  else {
    stopMotor();
    Serial.println("STOPPED");
  }

  delay(100);
}

#include <SPI.h>
#include <RF24.h>

RF24 radio(9, 10);                        // CE, CSN
const byte address[6] = "NODE1";

struct Packet {                           // the structure MUST BE IDENTICAL on both boards
  uint16_t counter;
  int16_t  temperature;                   // in tenths of a degree, as an integer
  bool     button;
};

Packet data = {0, 0, false};

void setup() {
  Serial.begin(9600);
  pinMode(2, INPUT_PULLUP);

  radio.begin();
  radio.openWritingPipe(address);
  radio.setPALevel(RF24_PA_LOW);          // low power for bench testing
  radio.setDataRate(RF24_250KBPS);        // low speed -> longer range
  radio.stopListening();                  // transmit mode
}

void loop() {
  data.counter++;
  data.temperature = (int16_t)(analogRead(A0) * 0.489);   // example
  data.button = !digitalRead(2);

  bool sent = radio.write(&data, sizeof(data));

  Serial.print("Packet ");  Serial.print(data.counter);
  Serial.println(sent ? " - acknowledged" : " - FAILED");

  delay(500);
}

#include <SPI.h>
#include <RF24.h>

RF24 radio(9, 10);
const byte address[6] = "NODE1";

struct Packet {
  uint16_t counter;
  int16_t  temperature;
  bool     button;
};

Packet data;
uint16_t lastCounter = 0;

void setup() {
  Serial.begin(9600);
  pinMode(3, OUTPUT);                     // LED on another pin: D9-D13 are used by SPI

  radio.begin();
  radio.openReadingPipe(0, address);
  radio.setPALevel(RF24_PA_LOW);
  radio.setDataRate(RF24_250KBPS);
  radio.startListening();                 // receive mode
}

void loop() {
  if (radio.available()) {
    radio.read(&data, sizeof(data));

    digitalWrite(3, data.button);

    // detecting lost packets
    if (data.counter != lastCounter + 1 && lastCounter != 0) {
      Serial.print("!! lost ");
      Serial.print(data.counter - lastCounter - 1);
      Serial.println(" packets");
    }
    lastCounter = data.counter;

    Serial.print("Packet #"); Serial.print(data.counter);
    Serial.print("  T = ");   Serial.print(data.temperature / 10.0, 1);
    Serial.print(" C  button = "); Serial.println(data.button ? "pressed" : "released");
  }
}

const uint8_t TRIG_PIN = 9;
const uint8_t ECHO_PIN = 10;

float speedOfSound(float tempC) {
  return (331.3 + 0.606 * tempC) / 10000.0;   // cm/us
}

float measureDistance(float tempC) {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);                       // the trigger pulse
  digitalWrite(TRIG_PIN, LOW);

  unsigned long duration = pulseIn(ECHO_PIN, HIGH, 30000UL);   // 30 ms limit

  if (duration == 0) return -1.0;              // no echo

  return (duration * speedOfSound(tempC)) / 2.0;  // round trip -> divide by 2
}

void setup() {
  Serial.begin(9600);
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  pinMode(3, OUTPUT);
}

void loop() {
  float d = measureDistance(20.0);

  if (d < 0) {
    Serial.println("No echo - object too far");
    digitalWrite(3, LOW);
  } else {
    Serial.print("Distance = "); Serial.print(d, 1); Serial.println(" cm");
    digitalWrite(3, d < 20.0);                 // warning under 20 cm
  }

  delay(100);                                   // avoid interference between readings
}

/* The four tasks are the functions written in the applications above.
   They are left empty here, so only the skeleton is clearly visible: */
void readDistance()    { /* application 4 */ }
void readTemperature() { /* application 1 */ }
void sendTelemetry()   { /* application 3 */ }
void updateMotor()     { /* application 2 */ }
void stopMotor()       { /* stops the motor's PWM */ }

unsigned long tDHT = 0, tDist = 0, tRadio = 0;
const unsigned long P_DHT = 2000, P_DIST = 100, P_RADIO = 500;

volatile bool emergencyStop = false;

void stopButton() { emergencyStop = true; }     // a very short ISR

void setup() {
  attachInterrupt(digitalPinToInterrupt(2), stopButton, FALLING);
}

void loop() {
  unsigned long now = millis();

  if (emergencyStop) {                            // has the highest priority
    stopMotor();
    return;
  }

  if (now - tDist >= P_DIST) {
    tDist = now;
    readDistance();
  }

  if (now - tDHT >= P_DHT) {
    tDHT = now;
    readTemperature();
  }

  if (now - tRadio >= P_RADIO) {
    tRadio = now;
    sendTelemetry();
  }

  updateMotor();                          // on every iteration
}