Nota

Ciao, benvenuto nella comunità degli appassionati di SunFounder Raspberry Pi, Arduino e ESP32 su Facebook! Approfondisci le tue conoscenze su Raspberry Pi, Arduino e ESP32 con altri appassionati.

Perché unirti?

• Supporto Esperto: Risolvi problemi post-vendita e sfide tecniche con l’aiuto della nostra comunità e del nostro team.

• Impara e Condividi: Scambia suggerimenti e tutorial per migliorare le tue competenze.

• Anteprime Esclusive: Ottieni accesso anticipato agli annunci di nuovi prodotti e anteprime.

• Sconti Speciali: Approfitta di sconti esclusivi sui nostri prodotti più recenti.

• Promozioni e Giveaway Festivi: Partecipa a giveaway e promozioni festive.

👉 Pronto a esplorare e creare con noi? Clicca [Qui] e unisciti oggi!

Monitor Ambientale Bluetooth

Questo progetto utilizza un’app Android creata con MIT App Inventor per ricevere e visualizzare i dati ambientali da una scheda Arduino. La scheda Arduino raccoglie i dati da un sensore DHT11 per misurare temperatura e umidità. Una volta raccolti i dati, vengono trasmessi tramite Bluetooth. L’app visualizzerà i dati sullo schermo una volta ricevuti.

L’applicazione Android verrà costruita utilizzando una piattaforma web gratuita nota come MIT App Inventor. Il progetto rappresenta un’eccellente opportunità per familiarizzare con l’interfacciamento di un Arduino con uno smartphone.

Componenti Necessari

In questo progetto, avremo bisogno dei seguenti componenti.

È sicuramente conveniente acquistare un kit completo, ecco il link:

Nome	ARTICOLI IN QUESTO KIT	LINK
Elite Explorer Kit	300+	Elite Explorer Kit

Puoi anche acquistarli separatamente dai link sottostanti.

INTRODUZIONE DEI COMPONENTI	LINK PER L’ACQUISTO
Arduino Uno R4 WiFi	-
Breadboard	ACQUISTA
Cavi Jumper	ACQUISTA
Modulo Sensore di Umidità e Temperatura DHT11	ACQUISTA

1. Costruisci il Circuito

2. Crea l’App Android

L’applicazione Android verrà sviluppata utilizzando un’applicazione web gratuita nota come MIT App Inventor. MIT App Inventor è un eccellente punto di partenza per lo sviluppo Android, grazie alle sue funzionalità intuitive di drag-and-drop che consentono la creazione di applicazioni semplici.

Iniziamo.

1. Vai su Get Started with MIT App Inventor e clicca su «online tool» per accedere. Avrai bisogno di un account Google per registrarti su MIT App Inventor.

   

2. Dopo aver effettuato l’accesso, naviga su Projects -> Import project (.aia) from my computer. Successivamente, carica il file ble_environmental_monitor.aia situato nel percorso elite-explorer-kit-main\iot_project\08-bluetooth_environmental_monitor.

   Puoi anche scaricarlo direttamente qui: ble_environmental_monitor.aia

   

3. Una volta caricato il file .aia, vedrai l’applicazione nel software MIT App Inventor. Questo è un modello preconfigurato. Puoi modificare questo modello dopo aver familiarizzato con MIT App Inventor seguendo i passaggi successivi.

4. In MIT App Inventor, hai 2 sezioni principali: il Designer e i Blocks. Puoi passare da una sezione all’altra nell’angolo in alto a destra della pagina.

   

5. Il Designer ti permette di aggiungere pulsanti, testo, schermate e modificare l’estetica generale della tua applicazione.

   

6. Successivamente, c’è la sezione Blocks. Questa sezione ti consente di creare funzionalità personalizzate per la tua app, permettendoti di programmare ogni componente dell’interfaccia utente dell’app per ottenere le funzionalità desiderate.

   

7. Per installare l’applicazione su uno smartphone, naviga sulla scheda Build.

   

   • Puoi generare un file .apk. Dopo aver selezionato questa opzione, apparirà una pagina che ti permetterà di scegliere tra scaricare un file .apk o scansionare un codice QR per l’installazione. Segui la guida all’installazione per completare l’installazione dell’applicazione.

     Puoi anche scaricare il nostro APK precompilato qui: ble_environmental_monitor.apk

   • Se desideri caricare questa app su Google Play o un altro marketplace di app, puoi generare un file .aab.

3. Carica il Codice

1. Apri il file 08-bluetooth_environmental_monitor.ino nel percorso elite-explorer-kit-main\iot_project\08-bluetooth_environmental_monitor, oppure copia questo codice in Arduino IDE.

   Nota

   Per installare la libreria, utilizza l’Arduino Library Manager per cercare e installare «DHT sensor library» e «ArduinoBLE».

08-bluetooth_environmental_monitor.ino

/*
  This code is designed for an Arduino Uno R4 board to read temperature and humidity data 
  from a DHT11 sensor. It then transmits this data via Bluetooth Low Energy (BLE) to a connected 
  device. The code uses the DHT library for reading sensor data and the ArduinoBLE library for 
  Bluetooth communication. The BLE service and characteristics are set up according to the 
  specifications of the Bluetooth SIG for environmental sensing. Additionally, the code includes 
  functions for managing BLE connection and disconnection events, as well as a debug function 
  that prints sensor data to the serial monitor.

  Board: Arduino Uno R4 
  Component: DHT11
  Library: https://github.com/adafruit/DHT-sensor-library  (DHT sensor library by Adafruit)
           https://www.arduino.cc/reference/en/libraries/arduinoble/ (ArduinoBLE by Arduino)
*/


#include <DHT.h>
#include <ArduinoBLE.h>

#define DHTPIN 11      // Define the pin used to connect the sensor
#define DHTTYPE DHT11  // Define the sensor type

// Define UUIDs for BLE Environmental Sensing Service and Characteristics as per Bluetooth SIG specifications
// https://bitbucket.org/bluetooth-SIG/public/src/8a7ea26ae56d43e6fea88693232a01a78e28213e/assigned_numbers/uuids/service_uuids.yaml#lines-104:105
BLEService environmentalSensingService("181A");
// https://bitbucket.org/bluetooth-SIG/public/src/8a7ea26ae56d43e6fea88693232a01a78e28213e/assigned_numbers/uuids/characteristic_uuids.yaml#lines-299:303
BLEShortCharacteristic temperatureCharacteristic("2A6E", BLERead | BLENotify);
BLEUnsignedShortCharacteristic humidityCharacteristic("2A6F", BLERead | BLENotify);

DHT dht(DHTPIN, DHTTYPE);  // Create a DHT object

unsigned long lastUpdateTime = 0;           // Timestamp of last sensor data update
const unsigned long updateInterval = 5000;  // Sensor data update interval (ms)

void setup() {

  Serial.begin(9600);  // Initialize serial communication at 9600 baud
  dht.begin();         // Initialize DHT sensor

  // Initialize BLE, halt if initialization fails
  if (!BLE.begin()) {
    Serial.println("starting Bluetooth® Low Energy module failed!");
    while (1)
      ;
  }

  setupBle();  // Setup BLE service and characteristics
}

void loop() {

  BLE.poll();  // Poll for BLE events

  // Check if it's time to update sensor data
  if (lastUpdateTime == 0 || millis() - lastUpdateTime > updateInterval) {
    float humidity = dht.readHumidity();        // Read humidity
    float temperature = dht.readTemperature();  // Read temperature

    // Check if any reads failed and exit early (to try again).
    if (isnan(humidity) || isnan(temperature)) {
      Serial.println(F("Failed to read from DHT sensor!"));
      return;
    }

    // Debug: print sensor data to serial monitor
    printDHT(humidity, temperature);

    // Update BLE characteristics with new sensor data
    temperatureCharacteristic.writeValue(round(temperature * 100.0));
    humidityCharacteristic.writeValue(round(humidity * 100.0));

    lastUpdateTime = millis();  // Update timestamp
  }
}

void printDHT(float h, float t) {
  // Print humidity and temperature data to serial monitor
  Serial.print(F("Humidity: "));
  Serial.print(h);
  Serial.print(F("%  Temperature: "));
  Serial.print(t);
  Serial.println(F("°C "));
}

void setupBle() {
  // Set advertised local name and service UUID:
  BLE.setLocalName("UNO R4 Home");
  BLE.setAdvertisedService(environmentalSensingService);

  // Add characteristics to the service
  environmentalSensingService.addCharacteristic(temperatureCharacteristic);
  environmentalSensingService.addCharacteristic(humidityCharacteristic);

  // Add service
  BLE.addService(environmentalSensingService);

  // Set initial characteristic values
  temperatureCharacteristic.writeValue(0);
  humidityCharacteristic.writeValue(0);

  // Set BLE event handlers for connection and disconnection
  BLE.setEventHandler(BLEConnected, blePeripheralConnectHandler);
  BLE.setEventHandler(BLEDisconnected, blePeripheralDisconnectHandler);

  // Start advertising
  BLE.advertise();
}

void blePeripheralConnectHandler(BLEDevice central) {
  // Handle BLE peripheral connect event
  digitalWrite(LED_BUILTIN, HIGH);  // Turn on built-in LED
  Serial.print(F("Connected to central: "));
  Serial.println(central.address());
}

void blePeripheralDisconnectHandler(BLEDevice central) {
  // Handle BLE peripheral disconnect event
  digitalWrite(LED_BUILTIN, LOW);  // Turn off built-in LED
  Serial.print(F("Disconnected from central: "));
  Serial.println(central.address());
}

1. Dopo aver selezionato la scheda e la porta corrette, clicca sul pulsante Upload.

2. Apri il monitor seriale (imposta il baudrate a 9600) per visualizzare i messaggi di debug.

4. Connessione dell’App e del modulo Bluetooth

Assicurati che l’applicazione creata in precedenza sia installata sul tuo smartphone.

1. Inizialmente, attiva il Bluetooth sul tuo smartphone.

   

2. Ora apri la nuova app Environmental Monitor installata.

   

3. Quando apri l’app per la prima volta, appariranno due richieste di autorizzazione in successione. Questi sono i permessi necessari per utilizzare il Bluetooth.

   
   

4. Nell’APP, clicca sul pulsante Connetti per stabilire una connessione tra l’APP e il modulo Bluetooth.

   

5. Questa pagina mostra un elenco di tutti i dispositivi Bluetooth abbinati. Scegli l’opzione xx.xx.xx.xx.xx.xx UNO R4 Home dall’elenco. Il nome di ogni dispositivo è elencato accanto al suo indirizzo MAC.

   
   

6. Se non vedi dispositivi nella pagina mostrata sopra, puoi provare ad attivare l’interruttore di localizzazione del dispositivo (alcune versioni di sistema Android includono l’interruttore di localizzazione con la funzione Bluetooth).

   
   

7. Dopo una connessione riuscita, sarai reindirizzato alla pagina principale dove verranno visualizzati temperatura e umidità.

   

5. Spiegazione del Codice

1. Importazione delle Librerie e Definizione delle Costanti

   • Importa le librerie necessarie e definisci le costanti per il pin e il tipo di sensore DHT.

   Nota

   Per installare la libreria, utilizza il Gestore Librerie Arduino per cercare e installare «DHT sensor library» e «ArduinoBLE».

   #include <DHT.h>
   #include <ArduinoBLE.h>
   #define DHTPIN 11
   #define DHTTYPE DHT11
   

2. Inizializzazione dei Servizi e delle Caratteristiche BLE

   • Definisci gli UUID per il Servizio e le Caratteristiche BLE Environmental Sensing. Stiamo utilizzando gli UUID predefiniti forniti da Bluetooth SIG. Il Servizio di rilevamento ambientale è assegnato a 0x181A, mentre 0x2A6E e 0x2A6F sono riservati rispettivamente per Temperatura e umidità.

   BLEService environmentalSensingService("181A");
   BLEShortCharacteristic temperatureCharacteristic("2A6E", BLERead | BLENotify);
   BLEUnsignedShortCharacteristic humidityCharacteristic("2A6F", BLERead | BLENotify);
   

3. Funzione di Setup

   • Inizializza la comunicazione Seriale, il sensore DHT e il BLE.

   void setup() {
     Serial.begin(9600);
     dht.begin();
     if (!BLE.begin()) {
       Serial.println("starting Bluetooth® Low Energy module failed!");
       while (1)
         ;
     }
     setupBle();
   }
   

4. Loop Principale

   • Controlla gli eventi BLE e aggiorna i dati del sensore a intervalli regolari.

   • La linea millis() - lastUpdateTime > updateInterval assicura che i dati del sensore vengano aggiornati ogni updateInterval millisecondi.

   void loop() {
     BLE.poll();
     if (millis() - lastUpdateTime > updateInterval) {
       // Leggi i dati del sensore e aggiorna le caratteristiche BLE
     }
   }
   

5. Funzioni BLE e di Debug

   Funzioni per configurare il BLE, stampare informazioni di debug e gestire gli eventi BLE.

   void printDHT(float h, float t) { /* ... */ }
   void setupBle() { /* ... */ }
   void blePeripheralConnectHandler(BLEDevice central) { /* ... */ }
   void blePeripheralDisconnectHandler(BLEDevice central) { /* ... */ }
   

   • printDHT(float h, float t): Utilizzata per stampare i dati di temperatura e umidità letti dal DHT11 sul monitor seriale. Questa funzione è per scopi di debug.

   • setupBle(): Inizializza il Bluetooth, inclusi il nome di broadcast, le caratteristiche e i servizi.

   • blePeripheralConnectHandler(BLEDevice central) e blePeripheralDisconnectHandler(BLEDevice central): Queste funzioni gestiscono gli eventi quando il Bluetooth si connette o si disconnette. Quando un dispositivo si connette con UNO R4 tramite Bluetooth, il LED integrato si accende. Quando il dispositivo si disconnette, il LED si spegne.