Pemantauan Kualitas Udara Kota Cerdas Berbasis LoRa

Tentang proyek ini

Kota Cerdas &Kualitas Udara

Bank Dunia mendefinisikan kota pintar sebagai kota yang padat teknologi. Ini berarti layanan publik yang sangat efisien.

Salah satu fitur mendasar dari kota pintar adalah menyediakan lingkungan yang berkelanjutan. Untuk lingkungan yang berkelanjutan, perlu dilakukan pemantauan kondisi lingkungan untuk mengidentifikasi sumber pencemaran dan mitigasinya. Dalam konteks ini, ribuan sensor kualitas udara ditempatkan untuk memberikan informasi real-time kepada pemerintah dan warga. Data ini dapat diubah menjadi informasi yang berguna, yang memungkinkan kami membuat keputusan yang lebih baik – apakah melakukan perencanaan transportasi atau mengetahui rute terbaik untuk berjalan kaki ke kantor.

Penginderaan kualitas udara sangat sesuai dengan visi kota pintar – memberikan informasi tentang kota yang sebelumnya tidak tersedia, memungkinkan orang membuat keputusan yang dapat meningkatkan kualitas hidup mereka.

Masalah &Solusi

Meningkatnya tingkat polusi udara di kota-kota besar telah menjadi perhatian utama karena risiko yang ditimbulkannya terhadap kesehatan manusia. Dalam konteks ini, teknologi telah menjadi alat yang sangat berguna dalam pemantauan kontaminasi dan kemungkinan mitigasi dampaknya. Secara khusus, ada usulan berbeda menggunakan paradigma internet of things (IoT) yang menggunakan sensor yang saling berhubungan untuk mengukur polutan yang berbeda. Jaringan node sensor pemantauan kualitas udara murah dapat digunakan untuk memantau kualitas udara dan parameter meteorologi. Oleh karena itu, melalui deteksi sumber polusi, kota dapat mengambil tindakan korektif dan meningkatkan kesehatan lingkungannya. Dengan memasang sistem pendeteksi bencana seperti banjir dan solusi pemantauan curah hujan di sekitar Anda. warga dapat diperingatkan sebelumnya jika terjadi peristiwa bencana. Pandangan holistik dapat diturunkan, memungkinkan pihak berwenang untuk membuat infrastruktur berbasis data dan keputusan perencanaan kebijakan.

Rencana Proyek

Dalam proyek ini, kita akan memantau beberapa parameter lingkungan yang paling penting seperti kebisingan, suhu, kelembaban, dan kualitas udara. Ini mentransmisikan data real-time melalui protokol komunikasi nirkabel ke platform cloud. Peralatan sepenuhnya berjalan dengan tenaga surya dengan baterai cadangan. Data dari perangkat dapat diakses di dasbor yang memvisualisasikan dan menganalisis data dalam format yang diinginkan.

Untuk pemantauan kualitas udara kota pintar, Anda harus menempatkan node sensor di lokasi yang berbeda. Dalam hal konsumsi daya dan biaya, bukanlah ide yang baik untuk menghubungkan setiap node sensor satu per satu ke cloud. Sebaiknya kumpulkan data dari semua node sensor di area kecil dan publikasikan semua data ke cloud dari satu gateway. LoRa dapat memberi kami keuntungan ini dan itulah mengapa saya memilih LoRa untuk proyek saya.

Untuk layanan cloud, saya menggunakan Grandeur untuk proyek saya. Grandeur adalah platform IoT ramah pembuat yang relatif baru di mana kami dapat menyimpan data kami dan memvisualisasikan data dengan membuat widget grafik menggunakan metode seret dan lepas. Mereka juga menyediakan Arduino, JavaScript, dan Python SDK dengan kode contoh. Jadi, seseorang dapat dengan mudah terhubung dengan layanan mereka menggunakan Arduino, NodeMCU, dan Raspberry Pi.

Cara terbaik untuk memberi daya pada node sensor adalah dengan menggunakan panel surya. Karena node sensor ditempatkan di lokasi terpencil yang berbeda dan sering mengganti baterai atau menyediakan daya dari sumber utilitas tidak selalu memungkinkan. Saya memberikan daya ke catatan sensor saya menggunakan panel surya dan baterai Li-ion.

Membuat Node Sensor

Saya ingin memantau kualitas udara, tingkat kebisingan, suhu &kelembaban. Jadi saya menggunakan sensor kualitas udara Grove, sensor kebisingan Grove, dan sensor suhu &kelembaban Grove DHT11. Satu hal yang baik tentang sensor Grove adalah Anda dapat menghubungkan semua sensor grove ke Arduino menggunakan pelindung dasar Grove tanpa penyolderan.

Untuk menyalakan sirkuit saya menggunakan panel surya Grove 1W dan baterai Li-ion. Untuk pengisian baterai menggunakan panel surya saya menggunakan charger solar Seeed LiPo Rider Pro yang memiliki built-in boost converter 5V. Jadi kita bisa dengan mudah menjalankan Arduino menggunakan output dari LiPo Rider.

Sebagian besar komponen yang digunakan di sini tersedia di Seeedstudio.com. Gambar berikut menunjukkan koneksi uji plug-and-play untuk semua komponen untuk node sensor.

Untuk mentransmisikan data sensor ke gateway IoT saya menggunakan transceiver Reyax LoRa. Gambar berikut menunjukkan Modul Lora Reyax RYLR998 dengan diagram pin.

Menyiapkan Mesin Reyax RYLR998 LoRa untuk Terhubung dengan Arduino Base Shield

RYLR998 memiliki 5 output pin jantan dan tidak kompatibel dengan pelindung dasar Grove. Untuk menghubungkannya ke Grove Shield, saya menyolder kabel Grove di perfboard dengan header female 5 pin. Sambungan sirkuit adalah sebagai berikut:

Modul RYLR998 LoRa dapat beroperasi dengan aman hingga 3.6V. Pin Arduino TX menghasilkan output 5V yang tidak aman untuk LoRa. Jadi, saya menggunakan pembagi tegangan untuk mendapatkan 3,4 V dari pin Arduino TX. Di sisi lain, pin Arduino RX bekerja dengan sempurna pada logika 3.3V. Jadi, saya menghubungkan pin TX dari LoRa ke pin RX dari Arduino secara langsung. Untuk operasi normal, pin RST dari LoRa harus dalam keadaan tinggi.

Sekarang modul LoRa di atas dapat dengan mudah dihubungkan ke pelindung dasar menggunakan rangkaian konverter berikut.

Namun sebelum menghubungkan Module ke base shield pastikan tombol power base shield pada posisi 3.3V seperti gambar di bawah ini.

Setelah menghubungkan modul LoRa ke pelindung dasar, kita dapat menguji dengan mengirimkan perintah AT ke modul dari Arduino.

Komunikasi menggunakan RYLR896 LoRa Transceiver

Untuk membangun komunikasi antara dua modul LoRa, mereka harus dapat menemukan satu sama lain melalui alamat. Skema pengalamatan ekosistem LoRa sedikit bergantung pada modul dan implementasi. Sederhananya, modul memungkinkan kita untuk mengatur id jaringan dan alamat. Modul pada jaringan yang sama (id jaringan yang sama) dapat berkomunikasi satu sama lain. Setiap modul seharusnya memiliki id (alamat) unik dalam jaringan. Jika sebuah modul memiliki alamat 0, modul tersebut dapat menerima data dari semua perangkat di jaringan.

Setiap modul dilengkapi dengan frekuensi default, id jaringan, dan alamat, tetapi Anda mungkin perlu mengubah nilai default. ID jaringan default untuk modul di atas adalah 18 dan alamat ke 0.

Kami tidak perlu mengubah apa pun saat ini untuk proyek demo kami. Tetapi jika Anda ingin mengubah parameter apa pun, silakan periksa lembar data untuk detail perintah AT.

Untuk mengirim pesan (HELLO RECEIVER!), kita hanya perlu mengirimkan perintah “AT+SEND=0, 15, HELLO RECEIVER!” pada koneksi serial modul. Nilai parameter pertama '0' adalah alamat modul penerima. Nilai berikutnya '15' adalah jumlah karakter/byte yang akan dikirim. Nilai parameter ketiga adalah pesan yang akan dikirim:'HELLO RECEIVER!' (15 karakter).

Kode untuk Node Sensor

Kode berikut dikembangkan untuk node sensor untuk mengumpulkan semua data sensor dan mengirimkannya ke gateway IoT.

#include "AirQuality.h" //grove perpustakaan kualitas udara
#include "Arduino.h"
#include "DHT.h"

# define DHTPIN 4 // ke pin digital apa sensor DHT terhubung
#define DHTTYPE DHT11 // model sensor DHT11 

DHT dht(DHTPIN, DHTTYPE);

AirQuality airqualitysensor;
int current_quality =-1;

const int sampleWindow =50; // Lebar jendela sampel dalam mS (50 mS =20Hz)
sampel int unsigned;
float noise;
suhu mengambang, lembab;
int airQuality;

 //---------------------------------------------- ----------------------------------------------
 // SETUP
 //----------------------------------------- -------------------------------------------------- -
pengaturan batal() 
{
 
 Serial.begin(115200); //Serial untuk lora
 airqualitysensor.init(14);
 dht.begin();

}
 
//----- -------------------------------------------------- ----------------------------------
// LOOP UTAMA
/ //------------------------------------------------- --------------------------------------------------
 
void loop() 
{
 noise =menghitung_suara_in_db();
 kualitas udara =menghitung_kualitas udara();
 menghitung_temp_humid();

 Temperatur string =String (temp);
 String kelembaban =String(lembab);
 String sound =String(noise);
 String air =String(airQuality);
 
 Nilai string =String(suhu)+","+ String(kelembaban)+","+ String(suara)+","+ String(udara);
 String cmd ="AT+SEND=0,,"+String (nilai.panjang())+","+nilai; //AT+SEND=,,
 Serial.println(cmd); //dikirim ke lora
 
 delay(15000);
}

//fungsi ini menghitung tingkat suara dalam dB
float count_sound_in_db(){
 unsigned long startMillis=milis(); // Awal jendela sampel
 float peakToPeak =0; // level puncak ke puncak
 
 unsigned int signalMax =0; //nilai minimum
 unsigned int signalMin =1024; //nilai maksimum
 
 // mengumpulkan data untuk 50 mS
 while (millis() - startMillis  {
 sample =analogRead(A1); //mendapatkan pembacaan dari mikrofon
 if (sampel <1024) // membuang pembacaan palsu
 {
 if (sampel> signalMax)
 {
 signalMax =sample; // simpan hanya level maksimum
 }
 else if (sampel  {
 signalMin =sample; // simpan hanya level minimum
 }
 }
 }
 peakToPeak =signalMax - signalMin; // max - min =amplitudo puncak-puncak
 //Serial.println(peakToPeak); //tulis desiBel yang terkalibrasi
 float db =map(peakToPeak,0,1000,48,120); //kalibrasi untuk desiBel
 //Serial.print(db); //tulis desiBel yang terkalibrasi
 //Serial.println(" dB"); //tulis satuan
 return db;
}

int count_air_quality(){
 current_quality=airqualitysensor.slope();
 /*
 if (kualitas_saat ini>=0)// jika data yang valid dikembalikan.
 {
 if (kualitas_kualitas==0)
 Serial.println("Polusi tinggi! Paksa sinyal aktif"); 
 else if (current_quality==1)
 Serial.println("Polusi tinggi!");
 else if (current_quality==2)
 Serial.println("Polusi rendah !");
 else if (current_quality ==3)
 Serial.println("Fresh air");
 }
 */
 return current_quality;
}

void count_temp_humid(){
 // Membaca suhu atau kelembaban membutuhkan waktu sekitar 250 milidetik!
 // Pembacaan sensor mungkin juga 'lama' hingga 2 detik ( sensornya sangat lambat)
 float h =dht.readHumidity();
 // Membaca suhu sebagai Celcius (default)
 float t =dht.readTemperature();
 
 // Periksa apakah ada pembacaan yang gagal dan keluar lebih awal (untuk mencoba lagi).
 if (isnan(h) || isnan(t)) {
 //Serial.println("Gagal membaca dari sensor DHT!");
 return;
 }

 temp =t;
 lembab =h; 
 /*
 Serial.print("Kelembaban:");
 Serial.print(h);
 Serial.print(" %\t");
 Serial.print("Suhu:");
 Serial.print(t);
 Serial.print(" *C ");
 */
}
 
//interrupt service routine untuk sensor kualitas udara
ISR(TIMER1_OVF_vect)
{
 if(airqualitysensor.counter==61)//set 2 detik sebagai tugas yang terdeteksi
 {

 airqualitysensor.last_vol=airqualitysensor.first_vol;
 airqualitysensor.first_vol=analogRead(A0);
 airqualitysensor.counter=0;
 airqualitysensor.timer_index=1;
 PORTB=PORTB^0x20;
 }
 else
 {
 airqualitysensor.counter++;
 }
} 

Kode mengirimkan data sensor setiap 15 detik. Ubah waktu sesuai dengan kebutuhan Anda.

Unggah &Uji

Sekarang hubungkan semua sensor, unggah kode di atas dan uji di monitor serial. File sumber dilampirkan di bagian kode.

Menempatkan Komponen di dalam Kotak

Sekarang kita akan menempatkan semua sensor dan baterai di dalam kotak. Pertama, cetak 3D dua file STL yang dilampirkan di bagian lampiran. Gambar yang dicetak terlihat seperti gambar berikut.

Kotak lengkap akan terlihat seperti berikut. Anda mungkin memerlukan beberapa basis pengiriman berdasarkan kualitas printer Anda.

Setelah kotak disiapkan terlebih dahulu dipasang panel surya di bagian atas kotak. Kabel penghubung di dalam kotak melalui lubang atas.

Kemudian letakkan Arduino dengan pelindung dasar terpasang terlebih dahulu dengan beberapa gule panas atau selotip dua sisi. Tempatkan sensor lain satu per satu dan tempelkan di tempat yang tetap menggunakan lem panas.

Pasang baterai dan lipo rider pro dan terakhir tambahkan modul LoRa.

Sensor Node siap digunakan.

Mengonfigurasi Keagungan

Grandeur menyediakan layanan backend untuk perangkat IoT di mana pasangan perangkat-pengguna virtual dibuat. Model perangkat dijelaskan saat pembuatan sebagai objek JSON yang berisi berbagai variabel (suhu, kelembaban, tingkat_suara, kualitas_udara dalam kasus kami) yang dapat dibaca dan ditulis. Grandeur Canvas adalah aplikasi web yang dapat digunakan untuk memvisualisasikan status perangkat dari perangkat yang dipasangkan menggunakan widget grafis.

Untuk menggunakan Grandeur, kita harus membuat akun dan melakukan beberapa konfigurasi penting di platform. Lihat situs web mereka https://grandeur.dev/ untuk masuk ke dalam permainan.

1. Setelah masuk ke akun root, buat proyek baru :

2. Buat akun pengguna baru dari Tambahkan akun pilihan dari tab Beranda atau dari tab akun. Kami nanti akan masuk ke aplikasi kami dengan email dan kata sandi yang kami buat sekarang. Ini adalah fitur keren lain dari Grandeur:beberapa pengguna dapat menggunakan aplikasi Anda dengan masuk menggunakan email dan sandi . Setiap pengguna dapat memasangkan perangkatnya sendiri dan perangkat yang dipasangkan oleh satu pengguna menjadi tidak tersedia untuk orang lain. Otentikasi dibangun pada inti dari Grandeur. Pembuatan pengguna diilustrasikan di bawah ini:

3. Sekarang buat perangkat baru melalui tab perangkat. Operasi ini menghasilkan ID perangkat unik baru yang akan kita gunakan saat menulis kode untuk perangkat keras kita dan ID perangkat ini diperlukan untuk terhubung ke Grandure menggunakan API. Membuat perangkat juga menghasilkan accessToken. Jangan lupa untuk menyalinnya dan itu akan digunakan dalam kode perangkat keras dan tidak akan dapat diakses setelah menutup dialog . Anda harus menambahkan model perangkat sebelum menambahkan perangkat menggunakan prosedur berikut. Model perangkat digunakan untuk menggambarkan variabel apa yang dapat dikomunikasikan oleh/ke perangkat.

Dari model, klik Tambah dan beri nama model. Dalam Skema, letakkan semua variabel (4 dalam kasus kami) dalam format JSON. Pertahankan nilai 0 saat ini. Variabel ini akan diperbarui secara otomatis ketika kami akan mengirim data dari node perangkat kami.

 {"temp":0, "humid":0, "air":0, "noise":0} 

Setelah meletakkan skema, klik Tambah.

Setelah menambahkan model perangkat, klik opsi Tambah dari Perangkat dan pilih model yang baru saja Anda buat untuk menautkan model ke perangkat.

Berikan id perangkat dan klik untuk Mendaftar.

Salin token akses dan itu akan digunakan dalam kode perangkat keras dan tidak akan dapat diakses setelah menutup dialog.

Perangkat berhasil dibuat dan catat juga ID PERANGKAT. Ini juga akan diperlukan untuk pengkodean.

Pengguna tidak dapat berinteraksi dengan perangkat kecuali jika dipasangkan dengan perangkat tersebut. Ada dua cara untuk menyandingkan perangkat :1) menggunakan Cloud Dashboard, atau 2) melalui aplikasi web dengan menggunakan pairDevice() fungsi API perangkat. Cara kedua ini memiliki makna yang sangat kuat jika dilihat dari segi produksi. Seperti Anda sekarang dapat mengirimkan produk perangkat keras Anda, dan pengguna Anda dapat masuk ke aplikasi Anda dan menyatakan kepemilikan atas perangkat keras dengan memasangkannya. Berikut cara memasangkan perangkat Anda dengan pengguna menggunakan Dasbor Cloud:

Untuk memasangkan perangkat, klik Pasangkan dan pilih akun. Anda siap untuk melanjutkan ke langkah berikutnya.

4. Kita akan membuat kanvas sekarang.

Di menu sebelah kiri di dasbor, klik kanvas, atau buka https://canvas.grandeur.tech. Jika ini pertama kalinya Anda mengunjungi Canvas, Otorisasi tombol akan muncul. Otorisasi memberi Canvas akses ke pengguna dan perangkat proyek Anda. Mengklik tombol "Otorisasi" akan mengarahkan Anda kembali ke dasbor Grandeur di mana Anda akan diminta untuk memilih proyek yang Anda inginkan untuk mengikat Canvas.

Pilih widget grafik dan klik di atasnya. Menu Configure akan muncul dan kemudian klik untuk mengkonfigurasi untuk memberikan judul grafik dan mengatur variabel yang nilainya ingin Anda tampilkan dalam grafik ini.

Klik untuk Menyimpan.

Mengikuti prosedur yang sama, tambahkan 4 widget grafik untuk 4 variabel.

Setelah menghubungkan Canvas ke proyek Anda, Anda mungkin melihat layar login. Anda harus masuk ke sini sebagai pengguna proyek yang Anda buat sebelumnya, untuk itu Anda perlu membuat akun pengguna di proyek Anda. Anda dapat melakukannya dengan mengunjungi halaman akun di dasbor. Kemudian Anda dapat masuk ke Canvas dengan menggunakan kredensial pengguna baru ini.

Mempersiapkan Gateway LoRa IoT

Secara sederhana, IoT Gateway seperti router atau gateway jaringan rumah atau kantor yang menghubungkan sensor, modul IoT, dan perangkat pintar ke cloud. Gateway semacam itu memfasilitasi komunikasi antar perangkat Anda, menjaga keamanan, dan menyediakan antarmuka admin tempat Anda dapat melakukan fungsi dasar.

Gateway IoT yang sebenarnya berisi teknologi komunikasi yang menghubungkan perangkat akhir (sensor, aktuator, atau perangkat yang lebih kompleks) dan platform backend (data, perangkat, dan manajemen pelanggan) ke gateway. Ini memiliki platform komputasi yang memungkinkan aplikasi pra-instal atau yang ditentukan pengguna untuk mengelola data (untuk perutean dan komputasi di edge), perangkat, keamanan, komunikasi, dan aspek lain dari gateway.

Raspberry Pi dapat menjadi pilihan yang baik untuk gateway dengan banyak fleksibilitas tetapi untuk membuatnya tetap sederhana saya menggunakan Node MCU sebagai gateway untuk proyek ini. Node MCU akan menerima data dari modul LoRa menggunakan UART. Kemudian menggunakan Arduino SDK kami akan mengunggah data ke platform cloud Grandeur.

Firmware untuk Gateway

Kode berikut dikembangkan untuk gateway menggunakan Arduino SDK yang disediakan oleh Grandeur cloud. Data diterima dalam bentuk string dari LoRa menggunakan port UART. Kemudian data yang diterima diproses untuk memisahkan variabel individu dari nilai string yang dipisahkan koma. Nilai-nilai tersebut kemudian dikirim ke Grandeur menggunakan WiFi. Fungsi berikut digunakan untuk memisahkan variabel.

void process_received_data(){
 
 start_pos =inputString.indexOf(start_val);
 end_pos =inputString.indexOf(end_val);
 String data_string =inputString. substring(start_pos+1, end_pos-1);
 //Serial.println(data_string);
 //mengidentifikasi koma pada string
 int firstCommaIndex =data_string.indexOf(',');
 int secondCommaIndex =data_string.indexOf(',', firstCommaIndex+1);
 int thirdCommaIndex =data_string.indexOf(',', secondCommaIndex+1);
 //pisah koma dipisahkan nilai dari string data 
 String temperature =data_string.substring(0, firstCommaIndex);
 String kelembaban =data_string.substring(firstCommaIndex+1, secondCommaIndex);
 String noise_level =data_string.substring( secondCommaIndex+1, thirdCommaIndex);
 String air_auality =data_string.substring(thirdCommaIndex+1);
 
 //Serial.println(temperature);
 //Serial.println( kelembaban);
 //Serial.println(noise);
 //Serial.prin tln(air_auality);

 temp =temperatur.toFloat();
 lembab =kelembaban.toFloat();
 noise =noise_level.toFloat();
 udara =air_auality.toFloat(); 

 Serial.println(temp);
 Serial.println(humid);
 Serial.println(noise);
 Serial.println(air);
 
 inputString ="";
 stringComplete =false;
 } 

Kode lengkap terlampir di bagian kode.

Visualisasi Data

#include "AirQuality.h" //grove air quality library#include "Arduino.h"#include "DHT. h"#define DHTPIN 4 // sensor DHT pin digital apa yang terhubung ke#define DHTTYPE DHT11 // model sensor DHT11 DHT dht(DHTPIN, DHTTYPE);AirQuality airqualitysensor;int current_quality =-1;const int sampleWindow =50; // Lebar jendela sampel dalam mS (50 mS =20Hz)sampel int tidak bertanda;kebisingan mengambang;suhu mengambang, lembab;int airQuality; //------------------------------------------------ -------------------------------------------- // MEMPERSIAPKAN //- -------------------------------------------------- ----------------------------------------- void setup() { Serial.begin( 115200); //Serial untuk lora airqualitysensor.init(14); dht.begin();} //----------------------------------------- -------------------------------------------------- -// MAIN LOOP//------------------------------------------- ------------------------------------------------- void loop() { noise =calculate_sound_in_db(); airQuality =calculate_air_quality(); calculate_temp_humid(); String temperature =String(temp); String humidity =String(humid); String sound =String(noise); String air =String(airQuality); String values =String(temperature)+","+ String(humidity)+","+ String(sound)+","+ String(air); String cmd ="AT+SEND=0,"+String(values.length())+","+values; //AT+SEND=
,, Serial.println(cmd); //sent to lora delay(15000);}//this function calculate sound level in dBfloat calculate_sound_in_db(){ unsigned long startMillis=millis(); // Start of sample window float peakToPeak =0; // peak-to-peak level unsigned int signalMax =0; //minimum value unsigned int signalMin =1024; //maximum value // collect data for 50 mS while (millis() - startMillis  signalMax) { signalMax =sample; // save just the max levels } else if (sample =0)// if a valid data returned. { if (current_quality==0) Serial.println("High pollution! Force signal active"); else if (current_quality==1) Serial.println("High pollution!"); else if (current_quality==2) Serial.println("Low pollution!"); else if (current_quality ==3) Serial.println("Fresh air"); } */ return current_quality;}void calculate_temp_humid(){ // Reading temperature or humidity takes about 250 milliseconds! // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor) float h =dht.readHumidity(); // Read temperature as Celsius (the default) float t =dht.readTemperature(); // Check if any reads failed and exit early (to try again). if (isnan(h) || isnan(t)) { //Serial.println("Failed to read from DHT sensor!"); kembali; } temp =t; humid =h; /* Serial.print("Humidity:"); Serial.print(h); Serial.print(" %\t"); Serial.print("Temperature:"); Serial.print(t); Serial.print(" *C "); */}//interrupt service routine for air quality sensorISR(TIMER1_OVF_vect){ if(airqualitysensor.counter==61)//set 2 seconds as a detected duty { airqualitysensor.last_vol=airqualitysensor.first_vol; airqualitysensor.first_vol=analogRead(A0); airqualitysensor.counter=0; airqualitysensor.timer_index=1; PORTB=PORTB^0x20; } else { airqualitysensor.counter++; }}

/* Including the SDK and WiFi library */#include #include #include SoftwareSerial LORA(D7, D8);/* Configurations */String deviceID ="your device id";String apiKey ="your api key";String token ="your device token";/* WiFi credentials */String ssid ="your wifi ssid";String password ="your wifi password";/* Create variable to hold project and device */Grandeur::Project project;Grandeur::Project::Device device;/* Variable to keep track of connection state and time */int connected =0;uint32_t lastUpdate =0;String inputString =""; // a string to hold incoming databoolean stringComplete =false; // whether the string is complete//:and % was set from the transmitter node for the eage of data separationchar start_val =':';char end_val ='%';int start_pos =0;int end_pos =0;float temp =0;float humid =0;float air =0;float noise =0;/* Function to check device's connection status */void onConnection(bool status) { switch(status) { case CONNECTED:Serial.println("Device is connected to the cloud."); /* Record connection state and time */ connected =1; lastUpdate =millis(); kembali; case DISCONNECTED:Serial.println("Device is disconnected from the cloud."); connected =0; kembali; }}/* Function to connect to WiFi */void connectWiFi() { /* Set mode to station */ WiFi.mode(WIFI_STA); /* Connect using the ssid and password */ WiFi.begin(ssid, password); /* Block till the WiFi is connected */ while (WiFi.status() !=WL_CONNECTED) { delay(500); Serial.print("."); } /* Print message */ Serial.println(""); Serial.println("WiFi connected"); /* And IP address */ Serial.println(WiFi.localIP());}/* Function to confirm that data has been updated */void dataCallback(const char* code, Var res) { /* If the update was recorded successfully */ if(code =="DEVICE-DATA-UPDATED") { //Serial.println("Updated DATA"); /* Get data */ double temp_data =(double) res["update"]["temp"]; double humid_data =(double) res["update"]["humid"]; double noise_data =(double) res["update"]["noise"]; double air_data =(double) res["update"]["air"]; /* Print */ Serial.printf("Temperature:%f Humidity:%f Noise Level:%f Air Quality:%f\n", temp_data, humid_data, noise_data, air_data); kembali; } /* If the summary could not be updated. */ Serial.println("Failed to Update DATA"); return;}/* Function to send updated current and power readings */void sendUpdate() { Var data; //JSON data format set in Grandeur:{"temp":0, "humid":0, "air":0, "noise":0} data["temp"] =temp; data["humid"] =humid; data["noise"] =noise; data["air"] =air; /* Record update */ //device.data().set("", data, dataCallback); //send JSON device.data().set("temp", temp, dataCallback); device.data().set("humid", humid, dataCallback); device.data().set("noise", noise, dataCallback); device.data().set("air", air, dataCallback); //delay(2000);}void setup() { /* Begin the serial */ Serial.begin(9600); LORA.begin(115200); inputString.reserve(200); /* Connect to WiFi */ connectWiFi(); /* Initializes the global object "grandeur" with your configurations. */ project =grandeur.init(apiKey, token); /* Get reference to device */ device =project.device(deviceID); /* Sets connection state update handler */ project.onConnection(onConnection);}void loop() { serialEvent(); project.loop(WiFi.status() ==WL_CONNECTED); /* Send update to server */ if (stringComplete) { process_received_data(); if (connected) sendUpdate(); }}void serialEvent() { while (LORA.available()) { // get the new byte:char inChar =(char)LORA.read(); // if the incoming character is a newline, set a flag // so the main loop can do something about it:if (inChar =='\n') { stringComplete =true; } else // add it to the inputString:inputString +=inChar; }}void process_received_data(){ start_pos =inputString.indexOf(start_val); end_pos =inputString.indexOf(end_val); String data_string =inputString.substring(start_pos+1, end_pos-1); //Serial.println(data_string); //identifying commas inn the string int firstCommaIndex =data_string.indexOf(','); int secondCommaIndex =data_string.indexOf(',', firstCommaIndex+1); int thirdCommaIndex =data_string.indexOf(',', secondCommaIndex+1); //seperating comma seperated value from the data string String temperature =data_string.substring(0, firstCommaIndex); String humidity =data_string.substring(firstCommaIndex+1, secondCommaIndex); String noise_level =data_string.substring(secondCommaIndex+1, thirdCommaIndex); String air_auality =data_string.substring(thirdCommaIndex+1); //Serial.println(temperature); //Serial.println(humidity); //Serial.println(noise); //Serial.println(air_auality); temp =temperature.toFloat(); humid =humidity.toFloat(); noise =noise_level.toFloat(); air =air_auality.toFloat(); Serial.println(temp); Serial.println(humid); Serial.println(noise); Serial.println(air); inputString =""; stringComplete =false; }