Aplicații practice integrate

#include <DHT.h>

#define PIN_DHT  7
#define TIP_DHT  DHT11

DHT senzor(PIN_DHT, TIP_DHT);

unsigned long ultimaCitire = 0;
const unsigned long INTERVAL = 2000;   // respecta intervalul minim

float tMin = 999, tMax = -999;         // valori extreme de la pornire

void setup() {
  Serial.begin(9600);
  senzor.begin();
  Serial.println("Statie meteo pornita");
}

void loop() {
  if (millis() - ultimaCitire < INTERVAL) return;   // temporizare neblocanta
  ultimaCitire = millis();

  float umiditate   = senzor.readHumidity();
  float temperatura = senzor.readTemperature();

  if (isnan(umiditate) || isnan(temperatura)) {     // VERIFICARE obligatorie
    Serial.println("Eroare la citirea senzorului!");
    return;
  }

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

  float indiceCaldura = senzor.computeHeatIndex(temperatura, umiditate, false);

  Serial.print("T = ");        Serial.print(temperatura, 1);
  Serial.print(" C   RH = ");  Serial.print(umiditate, 1);
  Serial.print(" %   resimtit = "); Serial.print(indiceCaldura, 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 trebuie sa fie pin PWM
const uint8_t PIN_POT = A0;
const uint8_t DUTY_MINIM = 60;             // sub aceasta valoare motorul nu porneste

void setSens(bool inainte) {
  digitalWrite(IN1, inainte ? HIGH : LOW);
  digitalWrite(IN2, inainte ? LOW  : HIGH);
}

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

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

void loop() {
  uint16_t brut = analogRead(PIN_POT);

  // zona moarta la mijloc: sub 490 inapoi, peste 530 inainte, intre ele oprit
  if (brut < 490) {
    setSens(false);
    uint8_t duty = map(brut, 489, 0, DUTY_MINIM, 255);
    analogWrite(ENA, duty);
    Serial.print("INAPOI  duty="); Serial.println(duty);
  }
  else if (brut > 530) {
    setSens(true);
    uint8_t duty = map(brut, 531, 1023, DUTY_MINIM, 255);
    analogWrite(ENA, duty);
    Serial.print("INAINTE duty="); Serial.println(duty);
  }
  else {
    opreste();
    Serial.println("OPRIT");
  }

  delay(100);
}

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

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

struct Pachet {                           // structura trebuie IDENTICA pe ambele placi
  uint16_t contor;
  int16_t  temperatura;                   // in zecimi de grad, ca intreg
  bool     buton;
};

Pachet date = {0, 0, false};

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

  radio.begin();
  radio.openWritingPipe(adresa);
  radio.setPALevel(RF24_PA_LOW);          // putere redusa pentru teste pe masa
  radio.setDataRate(RF24_250KBPS);        // viteza mica -> raza mai mare
  radio.stopListening();                  // mod emisie
}

void loop() {
  date.contor++;
  date.temperatura = (int16_t)(analogRead(A0) * 0.489);   // exemplu
  date.buton = !digitalRead(2);

  bool trimis = radio.write(&date, sizeof(date));

  Serial.print("Pachet ");  Serial.print(date.contor);
  Serial.println(trimis ? " - confirmat" : " - ESUAT");

  delay(500);
}

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

RF24 radio(9, 10);
const byte adresa[6] = "NOD01";

struct Pachet {
  uint16_t contor;
  int16_t  temperatura;
  bool     buton;
};

Pachet date;
uint16_t ultimulContor = 0;

void setup() {
  Serial.begin(9600);
  pinMode(3, OUTPUT);                     // LED pe alt pin: D9-D13 sunt ocupati de SPI

  radio.begin();
  radio.openReadingPipe(0, adresa);
  radio.setPALevel(RF24_PA_LOW);
  radio.setDataRate(RF24_250KBPS);
  radio.startListening();                 // mod receptie
}

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

    digitalWrite(3, date.buton);

    // detectarea pachetelor pierdute
    if (date.contor != ultimulContor + 1 && ultimulContor != 0) {
      Serial.print("!! pierdute ");
      Serial.print(date.contor - ultimulContor - 1);
      Serial.println(" pachete");
    }
    ultimulContor = date.contor;

    Serial.print("Pachet #"); Serial.print(date.contor);
    Serial.print("  T = ");   Serial.print(date.temperatura / 10.0, 1);
    Serial.print(" C  buton = "); Serial.println(date.buton ? "apasat" : "liber");
  }
}

const uint8_t PIN_TRIG = 9;
const uint8_t PIN_ECHO = 10;

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

float masoaraDistanta(float tempC) {
  digitalWrite(PIN_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_TRIG, HIGH);
  delayMicroseconds(10);                       // impulsul de declansare
  digitalWrite(PIN_TRIG, LOW);

  unsigned long durata = pulseIn(PIN_ECHO, HIGH, 30000UL);   // limita 30 ms

  if (durata == 0) return -1.0;                // fara ecou

  return (durata * vitezaSunet(tempC)) / 2.0;  // dus-intors -> impartit la 2
}

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

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

  if (d < 0) {
    Serial.println("Fara ecou - obiect prea departe");
    digitalWrite(3, LOW);
  } else {
    Serial.print("Distanta = "); Serial.print(d, 1); Serial.println(" cm");
    digitalWrite(3, d < 20.0);                 // avertizare sub 20 cm
  }

  delay(100);                                   // evita interferenta intre masuratori
}

/* Cele patru sarcini sunt functiile scrise la aplicatiile de mai sus.
   Aici sunt lasate goale, ca sa se vada limpede doar scheletul: */
void citesteDistanta()    { /* aplicatia 4 */ }
void citesteTemperatura() { /* aplicatia 1 */ }
void trimiteTelemetrie()  { /* aplicatia 3 */ }
void actualizeazaMotorul(){ /* aplicatia 2 */ }
void opresteMotorul()     { /* opreste PWM-ul motorului */ }

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

volatile bool oprireUrgenta = false;

void butonOprire() { oprireUrgenta = true; }     // ISR foarte scurt

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

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

  if (oprireUrgenta) {                            // are prioritate maxima
    opresteMotorul();
    return;
  }

  if (acum - tDist >= P_DIST) {
    tDist = acum;
    citesteDistanta();
  }

  if (acum - tDHT >= P_DHT) {
    tDHT = acum;
    citesteTemperatura();
  }

  if (acum - tRadio >= P_RADIO) {
    tRadio = acum;
    trimiteTelemetrie();
  }

  actualizeazaMotorul();                          // la fiecare iteratie
}