Senzori

Senzorul de lumină Grove conține un fotorezistor care poate fi folosit pentru a detecta intensitatea luminoasă. Rezistența fotorezistorului scade odată cu creșterea intensității luminoase. Un amplificator operațional dual LM358 convertește variația rezistenței în variația tensiunii. Valoarea semnalului de ieșire este continuă, cu cât intensitatea luminoasă e mai mare cu atât tensiunea va fi mai mare.

Modulul poate fi utilizat pentru a construi diferite aplicații care să depindă de intensitatea luminoasă: spre exemplu, aprinderea unor lumini de veghe:

// Întrerupător luminos
int sensorPin = A6; // Pinul la care senzorul este conectat
int ledPin = 4; // Pinul la care LED-ul este conectat
int sensorValue = 0; // Valoarea senzorului (intrarea analogică)
 
void setup()
{
    pinMode(ledPin, OUTPUT);
    pinMode(sensorPin, INPUT);
    Serial.begin(9600);
}
 
void loop()
{
    sensorValue = analogRead(sensorPin); // Citește valoarea senzorului
 
    Serial.println(sensorValue); // Trimite către calculator valoarea senzorului
 
    if (sensorValue < 200)
    { // Aprinde LED-ul când e întuneric
        digitalWrite(ledPin, HIGH);
    }
    else
    { // Stinge LED-ul când e lumină
        digitalWrite(ledPin, LOW);
    }
    delay(200);
}

// Lumină controlată de sunet
int soundPin = A2; // Analog sound sensor is to be attached to analog
int ledPin = 4; // Digital LED is to be attached to digital
 
void setup()
{
    pinMode(ledPin, OUTPUT);
    pinMode(soundPin, INPUT);
    Serial.begin(9600);
}
 
void loop()
{
    int soundState = analogRead(soundPin); // Citește valoarea intensității sonore
    Serial.println(soundState); // Trimite către calculator valoarea intensității
 
    if (soundState > 400)
    { // Dacă sunetul e puternic, aprinde LED-ul
        digitalWrite(ledPin, HIGH);
        delay(100);
    }
    else
    { // În lipsa zgomotului, stinge LED-ul
        digitalWrite(ledPin, LOW);
    }
}

Senzorul de temperatură și umiditate din modulul Grove este DHT11. DHT11 este un senzor de umiditate și temperatură digital, utilizat în proiecte de electronică și automatizări. Senzorul are o precizie moderată și este capabil să măsoare temperatura în intervalul de 0-50 grade Celsius, cu o precizie de 2 grade Celsius, și umiditatea relativă a aerului în intervalul de 20-90%, cu o precizie de 5%. DHT11 folosește un protocol de comunicare digital și este disponibil într-o variantă care include și un rezistor de pull-up integrat, făcându-l ușor de utilizat în proiecte cu microcontrolere cum ar fi Arduino.

Biblioteca software pentru a putea accesa senzorul prin intermediul Arduino se găsește aici.

// Termometru digital
#include "DHT.h"
#include <Arduino.h>
#include <U8x8lib.h>
 
#define DHTPIN 3 // pinul Arduino la care este conectat senzorul
#define DHTTYPE DHT20 // tipul senzorului, în cazul acesta DHT11
DHT dht(DHTTYPE);
 
U8X8_SSD1306_128X64_NONAME_HW_I2C u8x8(U8X8_PIN_NONE);
 
void setup(void)
{
    Serial.begin(9600);
    Serial.println("Termometru Digital");
    Wire.begin();
    dht.begin();
    u8x8.begin();
    u8x8.setPowerSave(0);
    u8x8.setFlipMode(1);
}
 
void loop(void)
{
    float temp, humi;
    temp = dht.readTemperature();
    humi = dht.readHumidity();
 
    u8x8.setFont(u8x8_font_chroma48medium8_r);
    u8x8.setCursor(0, 33);
    u8x8.print("Temp:");
    u8x8.print(temp);
    u8x8.print("C");
    u8x8.setCursor(0, 50);
    u8x8.print("Umid:");
    u8x8.print(humi);
    u8x8.print("%");
    u8x8.refreshDisplay();
    delay(200);
}

Senzorul folosit pentru determinarea presiunii atmosferice este BMP280. BMP280 este un senzor de presiune atmosferică și temperatură, dezvoltat de Bosch Sensortec. Acesta este folosit într-o gamă largă de aplicații, inclusiv în industria aerospațială, domeniul medical și în dispozitive de monitorizare a vremii. Senzorul BMP280 este capabil să măsoare temperatura și presiunea atmosferică cu o precizie ridicată. Are o interfață digitală I2C sau SPI și poate funcționa cu o tensiune de alimentare între 1,8V și 5V. BMP280 este un senzor foarte popular în comunitatea Arduino și este utilizat în proiecte precum stații meteorologice, drone, roboți și multe altele.

Biblioteca software pentru utilizarea senzorului prin intermediul Arduino se găsește aici.

//Air pressure detection
#include "Seeed_BMP280.h"
#include <Wire.h>
 
BMP280 bmp280;
 
void setup()
{
    Serial.begin(9600);
    if (!bmp280.init())
    {
        Serial.println("Device not connected or broken!");
    }
}
 
void loop()
{
    float pressure;
 
    // get and print temperatures
    Serial.print("Temp: ");
    Serial.print(bmp280.getTemperature());
    Serial.println("C"); // The unit for  Celsius because original arduino don't support speical symbols
 
    // get and print atmospheric pressure data
    Serial.print("Pressure: ");
    Serial.print(pressure = bmp280.getPressure());
    Serial.println("Pa");
 
    // get and print altitude data
    Serial.print("Altitude: ");
    Serial.print(bmp280.calcAltitude(pressure));
    Serial.println("m");
    Serial.println("\n"); // add a line between output of different times.
    delay(1000);
}

Accelerometru digital cu 3 axe este un accelerometru cu 3 axe, inclus în gama de produse Grove. Este bazat pe cipul LIS3DHTR, care oferă selecție multiplă de interfețe și intervale de măsurare. LIS3DHTR este un accelerometru digital 3-axial, un senzor care măsoară accelerația (schimbarea vitezei) în cele trei axe de mișcare. Acest senzor se bazează pe cipul LIS3DHTR și este utilizat într-o varietate de aplicații care necesită măsurarea mișcării sau a schimbării accelerației, cum ar fi în aplicații de monitorizare a sănătății sau de control al mișcării în jocurile video. Senzorul LIS3DHTR poate fi conectat la un microcontroller sau la alte dispozitive electronice prin intermediul interfeței I2C, SPI sau ADC GPIO, iar în acest fel poate fi integrat cu ușurință într-un proiect Arduino utilizând un modul Grove - 3-Axis Digital Accelerometer (LIS3DHTR) Grove. În plus, acest accelerometru poate monitoriza temperatura din jur pentru a ajusta eroarea cauzată de aceasta.

Click aici pentru a descărca biblioteca software pentru interfațarea I2C cu LIS3DHTR.

// Măsurarea accelerației gravitaționale
#include "LIS3DHTR.h"
#ifdef SOFTWAREWIRE
    #include <SoftwareWire.h>
    SoftwareWire myWire(3, 2);
    LIS3DHTR<SoftwareWire> LIS; // Configurează I2C în software
    #define WIRE myWire
#else
    #include <Wire.h>
    LIS3DHTR<TwoWire> LIS; // Configurează I2C în hardware
    #define WIRE Wire
#endif
 
void setup()
{
    Serial.begin(9600);
    while (!Serial)
    {
    };
    LIS.begin(WIRE, 0x19); // Inițializează conexiunea I2C
    delay(100);
    LIS.setOutputDataRate(LIS3DHTR_DATARATE_50HZ);
}
void loop()
{
    if (!LIS)
    {
        Serial.println("LIS3DHTR nu s-a conectat.");
        while (1)
            ;
        return;
    }
    // 3 axis
    Serial.print("x:");
    Serial.print(LIS.getAccelerationX());
    Serial.print("  ");
    Serial.print("y:");
    Serial.print(LIS.getAccelerationY());
    Serial.print("  ");
    Serial.print("z:");
    Serial.println(LIS.getAccelerationZ());
 
    delay(500);
}

Acest program este creat pentru a citi date de la diferiti senzori si a le transmite prin intermediul unei interfete seriale la un computer. Senzorii utilizati sunt un senzor de umiditate si temperatura DHT20, un senzor de presiune BMP280, un accelerometru LIS3DHTR, un senzor de lumina si unul de sunet. In setup(), se initializeaza senzorii, se seteaza pinii si se incepe comunicarea prin interfata seriala. In loop(), se citesc datele de la senzori si se trimit prin interfata seriala, doar daca se primeste caracterul r de la computer. Datele sunt trimise in format CSV, folosind virgula ca separator si cu patru zecimale. Varianta imbunatatita, care permite comenzi mai complexe, poate fi consultata aici.

CSV (Comma Separated Values) este un format de fișier text utilizat pentru a stoca date structurate, în care datele sunt separate prin virgule sau alte delimitatoare, cum ar fi tabulatorul sau punctul și virgula. Fiecare linie din fișier reprezintă un înregistrare și fiecare câmp dintr-un înregistrare este separat prin delimitatorul specificat.

Acest format este popular din mai multe motive:

• Este ușor de utilizat și de înțeles atât de oameni, cât și de programe
• Poate fi deschis și editat într-un editor de text obișnuit sau într-un program de foi de calcul
• Este un format comun pentru import și export de date între aplicații software diferite
• Poate fi utilizat pentru a stoca date într-un mod compact și eficient, ocupând mai puțin spațiu decât alte formate, cum ar fi XML sau JSON.
• Este suportat de majoritatea limbajelor de programare și bazelor de date

De exemplu, fișierele CSV sunt folosite frecvent în domenii cum ar fi finanțele, marketingul, vânzările sau statisticile pentru a analiza și a importa/exporta date.

#include "DHT.h" // biblioteca pentru senzorul de umiditate și temperatură
#include "Seeed_BMP280.h" // biblioteca pentru senzorul de presiune
#include <Wire.h> // biblioteca prin protocolul I2C
#include "LIS3DHTR.h" // biblioteca pentru accelerometru
#include <U8x8lib.h> // biblioteca pentru ecranul OLED
 
#define DHTTYPE DHT20 // tipul senzorului de umiditate și temperatură, în cazul nostru DHT20
 
int lightPin = A6; // pinul la care senzorul de lumină este conectat
int soundPin = A2; // pinul la care senzorul de sunet este conectat
int ledPin = 4; // pinul la care ledul este conectat
 
DHT dht(DHTTYPE); // initializare senzor de umiditate și temperatură
BMP280 bmp280; // initializare senzor de presiune
LIS3DHTR<TwoWire> LIS; // initializare accelerometru
U8X8_SSD1306_128X64_NONAME_HW_I2C u8x8(U8X8_PIN_NONE); // initializare ecran OLED
 
void setup()
{
    pinMode(ledPin, OUTPUT); // setează pinul ledului ca pin de ieșire
    Wire.begin(); // pornire protocol I2C
    dht.begin(); // pornire senzor de umiditate și temperatură
    bmp280.init(); // pornire senzor de presiune
    LIS.begin(Wire, 0x19);  // pornire accelerometru
    delay(100); // așteaptă 100ms
    LIS.setOutputDataRate(LIS3DHTR_DATARATE_50HZ); // seteaza rata de esantionare a accelerometrului la 50Hz
    u8x8.begin(); // pornire ecran OLED
    u8x8.setPowerSave(0); // dezactivează modul de economisire a energiei
    u8x8.setFlipMode(1); // rotește ecranul
    u8x8.setFont(u8x8_font_chroma48medium8_r); // setează fontul
    Serial.begin(9600); // pornire interfață serială
}
 
/**
 * Pentru a citi datele de la senzori, vom folosi formatul CSV (comma separated values), adică datele vor fi separate prin virgulă.
 * Vom citi datele de la senzori și le vom trimite prin interfața serială către PC numai dacă primim un caracter 'r' de la PC.
*/
 
void loop()
{
    // pentru ca vrem o comunicare sincronă între Arduino și PC, vom trimite datele doar dacă primim un caracter 'r' de la PC
    if (Serial.available() > 0 && Serial.read() == 'r') {
        float lightValue = ((float) analogRead(lightPin)) / 1023.0; // citește valoarea senzorului de lumină și o transformă într-un număr între 0 și 1
        float soundValue = ((float) analogRead(soundPin)) / 1023.0; // citește valoarea senzorului de sunet și o transformă într-un număr între 0 și 1
        float dhtTempValue = dht.readTemperature(); // citește valoarea temperaturii din senzorul de umiditate și temperatură
        float dhtHumiValue = dht.readHumidity(); // citește valoarea umidității din senzorul de umiditate și temperatură
        float bmpTempValue = bmp280.getTemperature(); // citește valoarea temperaturii din senzorul de presiune
        float bmpPresValue = bmp280.getPressure(); // citește valoarea presiunii din senzorul de presiune
        float bmpAltitudeValue = bmp280.calcAltitude(bmpPresValue); // calculează valoarea altitudinii din valoarea presiunii
        float accX = LIS.getAccelerationX(); // citește valoarea acceleratiei pe axa X
        float accY = LIS.getAccelerationY(); // citește valoarea acceleratiei pe axa Y
        float accZ = LIS.getAccelerationZ(); // citește valoarea acceleratiei pe axa Z
 
        digitalWrite(ledPin, HIGH); // aprinde ledul
        // trimite datele prin interfața serială în format CSV, folosind virgula ca separator si 4 zecimale
        Serial.print(lightValue, 4); Serial.print(","); // trimite valoarea senzorului de lumină prin interfața serială
        Serial.print(soundValue, 4); Serial.print(","); // trimite valoarea senzorului de sunet prin interfața serială
        Serial.print(dhtTempValue, 4); Serial.print(","); // trimite valoarea temperaturii prin interfața serială
        Serial.print(dhtHumiValue, 4); Serial.print(","); // trimite valoarea umidității prin interfața serială
        Serial.print(bmpTempValue, 4); Serial.print(","); // trimite valoarea temperaturii prin interfața serială
        Serial.print(bmpPresValue, 4); Serial.print(","); // trimite valoarea presiunii prin interfața serială
        Serial.print(bmpAltitudeValue, 4); Serial.print(","); // trimite valoarea altitudinii prin interfața serială
        Serial.print(accX, 4); Serial.print(","); // trimite valoarea acceleratiei pe axa X prin interfața serială
        Serial.print(accY, 4); Serial.print(","); // trimite valoarea acceleratiei pe axa Y prin interfața serială
        Serial.println(accZ, 4); // trimite valoarea acceleratiei pe axa Z prin interfața serială
        digitalWrite(ledPin, LOW);
 
        // afișează datele pe ecranul OLED
        u8x8.setCursor(0, 1);
        u8x8.print("TMP_1:"); u8x8.print(dhtTempValue); u8x8.print("C");
        u8x8.setCursor(0, 10);
        u8x8.print("HUMID:"); u8x8.print(dhtHumiValue); u8x8.print("%");
        u8x8.setCursor(0, 19);
        u8x8.print("TMP_2:"); u8x8.print(bmpTempValue); u8x8.print("C");
        u8x8.setCursor(0, 28);
        u8x8.print("PRESS:"); u8x8.print(bmpPresValue / 1000.0); u8x8.print("kPa");
        u8x8.setCursor(0, 37);
        u8x8.print("LIGHT:"); u8x8.print(lightValue);
        u8x8.setCursor(0, 46);
        u8x8.print("SOUND:"); u8x8.print(soundValue);
        u8x8.setCursor(0, 55);
        u8x8.print(accX, 1); u8x8.print(" "); u8x8.print(accY, 1); u8x8.print(" "); u8x8.print(accZ, 1); u8x8.print(" ");
        u8x8.refreshDisplay(); // actualizează ecranul OLED
    }
}