Getting_Started_With_LoRa
1.0.0
Proyek ini berupaya melakukan uji kecil teknologi transmisi LORA untuk mengumpulkan informasi yang dapat digunakan oleh CTIC Foundation. Informasi akan dikirim dari perangkat akhir (node atau pelanggan), informasi ini akan dikumpulkan oleh perangkat gateway dan ini, pada gilirannya, akan meneruskannya ke server untuk menyimpannya.
Lora adalah teknologi nirkabel (seperti WiFi, Bluetooth, LTE, Sigfox atau ZigBee) yang menggunakan jenis modulasi frekuensi radio yang dipatenkan oleh Semtech.
Saat ini teknologi dikelola oleh Alliance Lora yang mensertifikasi semua pembuatan perangkat keras yang berupaya bekerja dengan teknologi ini.
Lora memiliki toleransi yang tinggi terhadap gangguan , sensitivitas tinggi untuk menerima data (-168dB), konsumsi yang sangat rendah (perangkat dapat bertahan satu dekade dengan baterai tunggal) dan kisaran 10 hingga 20 km (tergantung pada apakah visi langsung atau topologi lahan tersedia). Di sisi lain, kami menemukan transfer data yang sangat rendah (hingga 255 byte).
Semua ini membuat teknologi transfer ini bermanfaat untuk jarak besar atau jaringan IoT yang tidak membutuhkan atau tidak memiliki akses ke arus listrik.
Lora bekerja pada frekuensi gratis (ini adalah 868MHz di Eropa, 916MHz di Amerika atau 433MHz di Asia, misalnya) yang, mengumpulkan non -perlu untuk memiliki pemasok jaringan listrik dan penyedia telekomunikasi (kami menggunakan radiofrekuensi), memungkinkan untuk memancarkan dan mengirim informasi tanpa risiko.
Kita dapat berkomunikasi dengan perangkat melalui Loremac (juga dikenal melalui Lora) atau oleh Lorawan.
Loramac : Digunakan untuk mengkomunikasikan dua perangkat satu sama lain dengan titik ke titik ke titik, satu mengirim informasi dan yang lain mengumpulkannya (atau sebaliknya).
Lorawan : Digunakan untuk mengkomunikasikan jaringan perangkat. Dalam pendekatan ini angka gateway muncul (perangkat yang mengumpulkan informasi dari satu atau lebih perangkat dan meneruskannya ke server). Di Lorawan, informasi harus disaring untuk mengetahui perangkat apa yang harus Anda dengarkan di gateway dan yang harus diabaikan, tetapi ini akan terlihat nanti. Pendekatan ini menggunakan topologi bintang.
Di sisi lain, di Lorawan , ada juga tiga jenis perangkat akhir atau node :
*Dalam contoh hanya dukungan untuk node Kelas A dan B (didukung oleh perpustakaan yang digunakan), tetapi hanya tipe A. yang hanya diimplementasikan
Jika pita frekuensi bebas di Eropa (868MHz) digunakan, beberapa batasan harus diperhitungkan:
Di setiap pita frekuensi ada beberapa saluran atau sub-band, dalam kasus Eropa (868MHz) kami menemukan 10 saluran bernomor dari 0 hingga 9. Tetapi, misalnya di Amerika (915MHz) kami dapat menemukan hingga 64.
Pengiriman informasi melalui satu saluran atau yang lain adalah tugas yang biasanya digunakan perpustakaan untuk digunakan.
Dalam beberapa Evices akhir dimungkinkan untuk memodifikasi DataRrate atau penyebar perangkat.
DataRrate dan SpreadingFactor terkait: DataRrate dari 0 menunjukkan SF12 dan DataRrate dari 5 menunjukkan SF7. Semua pada frekuensi 125kHz memiliki pengecualian berikut: Daterate 6 menunjukkan SF7 dengan 250kHz.
Dua perangkat (satu untuk node dan satu untuk gateway, yang juga harus memiliki konektivitas wifi) dan akun terkait di TTS ( jaringan Things ) atau ChirpStack (dapat menggunakan servernya sendiri di rumah). Dalam contoh ini, baik contoh Loremac dan Lorawan yang memanfaatkan node Arduino dan gateway Pycom.
Untuk memulai, itu cukup untuk mengkloning repositori:
git clone https://github.com/Javieral95/Getting_Started_With_LoRa.git
Dan kemudian mengunggah proyek yang relevan ke perangkat
Mengapa dua ide? Sederhana, ekstensi Pymakr hampir tidak berfungsi dalam kode studio visual. Jangan ragu untuk menggunakan ruang kerja yang paling nyaman.
Kedua perangkat memiliki Antera Lora yang terhubung dengan mereka.
Catatan : Kode untuk ArduinomKR1300 (lebih siap untuk digunakan seperti Lora End-Device) dan kode untuk menggunakan Pysense atau Pytrack sebagai ujung-EVEX juga termasuk dalam repo.
Contoh Loramac (ditemukan dalam folder homonim) adalah fungsional penggunaan perangkat akhir Arduino dan gateway Pycom.
Node hanya mengirimkan informasi hardcode dan gateway hanya terhubung ke Lora dan WiFi, menerima informasi PYCOM dan mencetak data yang dibaca (meskipun telah menerapkan fungsi mengirim data ke jaringan).
Penggunaan server jaringan dibagikan.
Untuk mengetahui lebih banyak, Anda dapat mengakses folder /loramac .
Untuk penggunaan contoh -contoh ini (yang fungsional memanfaatkan perangkat akhir Arduino dan gateway Pycom), server diperlukan untuk memvisualisasikan data. Dalam contoh ini, penggunaan Network Things dan ChirpStack (sebelumnya dikenal sebagai Loraserver) telah ditangani.
Untuk mengetahui lebih lanjut, Anda dapat mengakses folder /Lorawan dan kemudian terus berkonsultasi dengan dokumentasi ini.
Ada dua jenis otentikasi di Lorawan:
*Dalam contoh saat ini hanya OTAA yang dibuat.
Seperti yang disebutkan sebelumnya, kami akan membutuhkan server. Untuk contoh ini, versi gratis dari Things Network, server ChirpStack yang dimiliki oleh Pycom dan lainnya yang digunakan di rumah telah digunakan.
Ini adalah alternatif yang paling dapat diandalkan, aman, dan terdokumentasi lebih baik. Namun, semuanya menunjukkan bahwa itu akan berhenti terbuka (ada batas 50 node per aplikasi).
Membuat aplikasi sederhana, akses menu dan klik tombol +. Setelah kami menunjukkan nama aplikasi, ID unik dan deskripsi.
Saat aplikasi dibuat, kami dapat menambahkan perangkat akhir (node) mengklik tombol +.
Gateway adalah perangkat yang bertanggung jawab untuk mengirim lalu lintas yang berasal dari beberapa perangkat akhir (termasuk beberapa aplikasi) dan maju ke server. Membuat gateway juga sederhana, klik tombol + dan isi formulir yang memperhatikan konsep -konsep berikut:
Untuk dapat membaca data yang telah dikirim node ke server, perlu untuk memecahkan kode muatan, dalam hal TTN kami akan melakukannya untuk setiap perangkat, di tab Formatters Payload . Kami memilih bagaimana formatter mengetik opsi javascript dan:
function Decoder(bytes, port) {
// Decode plain text; for testing only
return {
myTestValue: String.fromCharCode.apply(null, bytes)
};
}
arduino_ttn_decoder.js Telah ditetapkan bahwa semua alamat heksadesimal dari jaringan hal -hal di walikota, tidak penting ketika memprogram perangkat tetapi kesalahan telah diderita dalam versi sebelumnya.
Ini adalah alternatif open source, masih dalam pengembangan dan dokumentasinya tidak begitu baik. Namun, itu berfungsi dan memungkinkan server diluncurkan.
Pycom menawarkan server ChirpStack untuk menghubungkan perangkat gateway Anda.
Aplikasi ini mirip dengan yang dirinci di bagian jaringan Things.
Anda harus pergi ke profil perangkat bagian server, sekali di dalamnya akses ke profil yang menarik (OTAA dalam kasus ini) dan memodifikasi versi:
Untuk membuat gateway, akses nama yang sama dan klik tombol +. Isi formulir memberikan perhatian khusus pada bidang ID gateway (64 bit dalam heksadesimal yang mengidentifikasi gateway), Anda dapat membuat ChirpStack menghasilkannya untuk Anda tetapi Mac perangkat biasanya digunakan (jika Anda tidak mengetahuinya di bagian yang menjelaskan gateway pycom itu akan detail sebagai memperolehnya).
Anda dapat meninggalkan nilai default lainnya.
Untuk membaca data yang telah dikirim node ke server, perlu untuk mendekodifikasi muatan, dalam hal ChirpStack kami akan melakukannya untuk setiap profil perangkat, di perangkat Propiles_ kami mengakses profil yang menarik minat kami (dalam hal ini OTAA) dan kami mengakses tab Codec :
Kami memilih dalam fungsi codec decipt khusus dan:
function Decode(fPort, bytes) {
var tempObj = new Object();
tempObj.data=bytes;
tempObj.decodedData = String.fromCharCode.apply(null, bytes);
tempObj.message = "Informacion recibida del nodo";
return tempObj;
}
arduino_chirpstark_decoder.js Telah ditetapkan bahwa semua alamat heksadesimal dari ChirpStack ada dalam minuskul, tidak penting ketika memprogram perangkat tetapi kesalahan telah diderita dalam versi sebelumnya.
ChirpStack menyediakan alternatif OpenSource untuk meluncurkan server pribadi kami di Lorawan, dan memungkinkan kami melakukannya dengan cara yang sederhana dan melalui wadah.
Itulah sebabnya repositori lain yang dimiliki oleh pendiri ChirpStack (Brocar) yang memungkinkan operasi ini: ChirpStack-Docker telah dikloning di repositori saat ini. Kami menemukannya di folder chirpstack-docker .
ChirpStack memiliki berbagai komponen dalam arsitekturnya untuk membuat layanan yang mampu beroperasi, mereka adalah sebagai berikut:
Cara menampilkan server dalam bentuk wadah memungkinkan kita untuk mengabstraksikan banyak komponen arsitektur, namun mereka dirinci di bawah ini:
Sebelum menggunakan, semua parameter yang diperlukan harus dikonfigurasi dalam file konfigurasi yang disimpan di papan konfigurasi .
Anda dapat berkonsultasi dengan dokumentasi resmi berikut:
CATATAN: File konfigurasi sensitif terhadap spasi kosong atau garis kosong (mereka telah ditemukan di jaring nyamuk), periksa file dan menghilangkan untuk menghindari kesalahan.
Seperti yang telah disebutkan sebelumnya, penyebaran dalam wadah sederhana dan terletak di direktori chirpstack-docker .
Setelah yang diperlukan sudah dikonfigurasi, cukup untuk ditempatkan di direktori dan peluncuran ChirpStack-Docker :
docker-compose up
Dengan konfigurasi default Anda dapat mengakses server ke arah lokal: 8080 . Pengguna akan menjadi admin dan kata sandi admin .
Mari kita mulai menambahkan konfigurasi dasar:
Setelah server dikonfigurasi, kami harus mendaftarkan gateway kami dan membuat aplikasi untuk merekam perangkat akhir kami. Proses ini dilakukan secara analog dengan yang dijelaskan di bagian sebelumnya dari dokumentasi ini: ChirpStack (Lora Server).
Selain itu, fungsi yang mendekode dan mengkodekan informasi yang diterima harus ditunjukkan, juga dijelaskan di bagian sebelumnya.
Kode yang digunakan untuk meluncurkan gateway dirinci di bawah ini dalam pycom (fipy dengan pytrack). Kode ini terletak di Lorawan/LorapyComgateway .
Perpustakaan Nanogateway Py telah digunakan yang memungkinkan Gateway diluncurkan dalam hitungan menit.
Nano-Gateway mengubah perangkat PyCom menjadi gerbang sederhana yang hanya mendengarkan saluran frekuensi pita (monochanal) , untuk mendengarkan lebih banyak band di Pycom, ada kemungkinan bahwa itu diperlukan untuk gateway komersial.
Dalam file konfigurasi segala yang diperlukan untuk menyesuaikan gateway:
WIFI_MAC = ubinascii.hexlify(machine.unique_id()) #.toUpper() para TTS
SERVER = 'loraserver.pycom.io' #(or url of your server)
GATEWAY_ID = WIFI_MAC[:6] + "ffff" + WIFI_MAC[6:12] #Minusculas: Chirpstack
NTP = "es.pool.ntp.org"
NTP_PERIOD_S = 3600
#WiFi settings (change it)
WLAN_SSID = "MyAwesomeWiFi" #"pycom-wifi"
WLAN_PASS = "CheckOutThisGoodPassword" #"securepassword"
WLAN_TIMEOUT_MS = 180000
### LoRaWAN for EU868 ###
LORA_FREQUENCY = 868500000
#Spreading Factor: (Higher value in SF=More distance but less speed transmision)
LORA_GW_DR = "SF7BW125" # DR_5,Can change in range: SF7 to SF15 (SF7B250 also exists)
LORA_NODE_DR = 5 #5 (6 uses 250Khz) for SF7, 4 for SF6.. all using 125Khz
###
def get_gateway_id():
print("Your gateway_id is: {}".format(GATEWAY_ID)) #The gateway is b'THIS_STRING'
return GATEWAY_ID
Catatan: Jika Anda menghubungkan gerbang Anda ke jaringan lokal tanpa koneksi internet, itu akan mengembalikan kesalahan saat menyinkronkan jam tangan. Anda bisa keluar dari langkah mengomentari baris kode berikut di fungsi start (self) dari file nanogateway.py seperti yang ditunjukkan oleh contoh berikut:
# get a time sync
self._log('Syncing time with {} ...', self.ntp_server)
#self.rtc.ntp_sync(self.ntp_server, update_period=self.ntp_period)
#while not self.rtc.synced():
# utime.sleep_ms(50)
self._log("RTC NTP sync complete")
Beberapa fungsi file utama tidak digunakan, hanya perlu meluncurkan gateway sebagai berikut dan sudah akan berfungsi.
def init_loraWAN_gateway():
print("Initializing LoRaWAN nano Gateway")
nanogw = NanoGateway(
id=config.GATEWAY_ID,
frequency=config.LORA_FREQUENCY,
datarate=config.LORA_GW_DR,
ssid=config.WLAN_SSID,
password=config.WLAN_PASS,
server=config.SERVER,
port=config.PORT,
ntp_server=config.NTP,
ntp_period=config.NTP_PERIOD_S
)
print("Ok! Now you have a LoRaWAN Gateway! Lets start it, wait . . .")
pycom.rgbled(0xAA0000)
nanogw.start()
nanogw._log('. . . Yeah! Nano gateway is connected and running, enjoy the log:')
pycom.rgbled(0x000000)
Pycom akan menjaga lampu merah sampai berhasil terhubung, setelah mendengarkan perangkat perangkat akan mem -flash LED hijau.
Berikut ini dirinci untuk mengoperasikan simpul kelas A menggunakan Arduino.
Teori menggunakan semua saluran yang tersedia di pita frekuensi, kemudian cara kekuatan hanya akan terlihat satu (tidak disarankan).
Perpustakaan McCi Arduino Lorawan telah digunakan yang memungkinkan Anda untuk mengabstraksikan banyak aspek komunikasi Lora. Telah diinstal oleh PlatformIO Library Manager.
Pada dasarnya kode yang digunakan untuk klien Arduino adalah yang ditemukan dalam contoh ttn-otaa.ino dari perpustakaan, kecuali untuk beberapa modifikasi.
Konfigurasi dibuat di dua file yang berbeda:
Semua konfigurasi yang terkait dengan Lorawan, seperti yang ditunjukkan di atas ditunjukkan dalam file Lorawan.cpp . Di awal dokumen, dirinci bahwa data harus ditunjukkan: App_eui , dev_eui dan app_key (mata ke format yang ditunjukkan di bawah).
Kemudian contoh di ChirpStack:
static const u1_t PROGMEM APPEUI[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
static const u1_t PROGMEM DEVEUI[8] = {0x7b, 0x6b, 0xff, 0x2c, 0x7b, 0x2c, 0x19, 0x5a};
static const u1_t PROGMEM APPKEY[16] = {0xbd, 0x21, 0x5a, 0x82, 0xb2, 0xf7, 0x92, 0xf3, 0xc7, 0xcb, 0xb2, 0x88, 0xc7, 0x55, 0x33, 0xe7};
Di bawah seluruh konfigurasi kunci, dalam file loraWan.cpp , kita dapat memilih apakah akan mengirim teks datar atau data dari sensor suhu dan kelembaban. Mengurai opsi yang diinginkan:
/******* Send data config *******/
// Use this to send a Hello world in plain text
// static uint8_t mydata[] = "Hello World!";
// Use this to send sensor data
const int neededBytes = 4; // 4 bytes: 2 for temperature and 2 for humidity, can change this value
static byte mydata[neededBytes];
static LoraEncoder encoder(mydata);
Bergantung pada informasi yang dikirim, decoding atau fungsi lain harus digunakan, seperti yang ditunjukkan dalam bagian dari jaringan Things dan ChirpStack.
Seperti yang terlihat sebelumnya, pelat Pycom nano-gateway hanya dapat membaca di saluran sementara perangkat final Arduino dapat disiarkan di semua saluran band (misalnya, di band Eropa ada 10 saluran). Meskipun tidak disarankan (aturan 1%mungkin dilanggar) dapat dipaksa untuk menggunakan hanya saluran dan frekuensi hanya karena masalah pengembangan dan pengujian.
Untuk ini, perlu untuk memodifikasi kode perpustakaan, lebih khusus lorabase_eu868.h (dalam kasus menggunakan frekuensi Eropa) dan memaksa frekuensi yang diinginkan untuk mengeluarkan sebagai berikut (amati bagaimana semua nilai telah dikodekan untuk menunjukkan frekuensi 868.MHZ):
enum {
EU868_F1 = 868500000, // g1 SF7-12
EU868_F2 = 868500000, // g1 SF7-12 FSK SF7/250
EU868_F3 = 868500000, // g1 SF7-12
EU868_F4 = 868500000, // g2 SF7-12
EU868_F5 = 868500000, // g2 SF7-12
EU868_F6 = 868500000, // g3 SF7-12
EU868_J4 = 868500000, // g2 SF7-12 used during join
EU868_J5 = 868500000, // g2 SF7-12 ditto
EU868_J6 = 868500000, // g2 SF7-12 ditto
};
enum {
EU868_FREQ_MIN = 868500000,
EU868_FREQ_MAX = 868500000
};
Fungsi berikut juga harus dipanggil pada awal fungsi Lora ( lorawan_startjob () :
// Define the single channel and data rate (SF) to use
void disableChannels(int selectedChannel, int dr)
{
// Disable all channels, except for the one defined above.
// ONLY FOR TESTING AND DEVELOPING!
for (int i = 0; i < 9; i++)
{ // For EU; for US use i<71
if (i != selectedChannel)
{
LMIC_disableChannel(i);
}
}
// Set data rate (SF) and transmit power for uplink
LMIC_setDrTxpow(dr, 14);
}
Saluran dan daterate yang akan dikonfigurasi berada di awal file, di baris (secara default: saluran 0 dan data yang diinginkan dari faktor penyebaran 7 yang nilainya 5):
/******* Channel config (only change if you want to uses a single channel) *******/
const int channel = 0; // Use if you want to use only one Band's Channel.
const int dr = DR_SF7; // Use if you want to use a specific datarate (The spreading factor mark the dr's value).
Ini akan membuat hilangnya paket berkurang secara signifikan, meskipun masih ada beberapa yang tidak diterima oleh gerbang.
Cukup salin proyek ke pelat Arduino Anda.
Toko buku berfungsi berdasarkan acara, dalam hal ini yang paling penting adalah otentikasi (ketika Anda selesai, Anda akan melihat kunci di konsol) dan pengiriman data.
Peristiwa di mana data dikirim adalah EV_TXComplete dalam fungsi Void OneVent (EV_T EV) dari file Lorawan.cpp , amati bahwa acara tersebut mencakup "RX Window", pada saat itu perangkat mendengarkan.
case EV_TXCOMPLETE:
Serial.println(F("EV_TXCOMPLETE (includes waiting for RX windows)"));
if (LMIC.txrxFlags & TXRX_ACK)
Serial.println(F("Received ack"));
if (LMIC.dataLen)
{
Serial.print(F("Received "));
Serial.print(LMIC.dataLen);
Serial.println(F(" bytes of payload"));
}
// Schedule next transmission
os_setTimedCallback(&sendjob, os_getTime() + sec2osticks(TX_INTERVAL), do_send);
break;
Fungsi, dalam file yang sama, di mana akan dirinci data apa yang dikirim do_send (komentar atau dekomen baris yang menyandikan informasi jika Anda ingin mengirim teks datar):
void do_send(osjob_t *j)
{
// Check if there is not a current TX/RX job running
if (LMIC.opmode & OP_TXRXPEND)
{
Serial.println(F("OP_TXRXPEND, not sending"));
}
else
{
// Leer datos de sensor y codificar (Libreria LoRa_Serialization).
am2315_readedData data = readAM2315Data();
encoder.writeTemperature(data.temp);
encoder.writeHumidity(data.hum);
// Comentar las dos lineas "encoder" para enviar texto plano
// Send packet
LMIC_setTxData2(1, mydata, sizeof(mydata), 0);
if (isLoopRunning)
{
freq = String(LMIC.freq);
Serial.println("-->Packet queued using freq = " + freq);
// Prepare upstream data transmission at the next possible time.
printSensorInfoInDisplay(data.temp, data.hum);
printLoraSentInDisplay(freq);
}
}
// Next TX is scheduled after TX_COMPLETE event.
}
Catatan : Kesalahan diderita yang mencegah simpul menerima paket punggung, jadi tidak mungkin untuk mengotentikasi perangkat di depan server. Ini telah ditambahkan dalam pengaturan pelanggan () (lebih khusus dalam fungsi lorawan_startjob () dari file lorawan.cpp ) baris kode berikut yang meningkatkan kesalahan jam maksimum sebesar 10%:
LMIC_setClockError(MAX_CLOCK_ERROR * 10 / 100);
Baik ChirpStack dan The Things Network menawarkan serangkaian integrasi untuk mengirim data yang diterima server kami ke layanan lain. Misalnya: kita dapat mengirim data ke database pengaruh, memanfaatkan MQTT, terhubung ke layanan AWS atau ...
Pada bagian ini kasus praktis akan terlihat di mana kita dapat menggunakan integrasi HTTP (Webhooks di jaringan Things) dan MQTT untuk mengirim data yang dikirim perangkat kami dan bahwa server kami menerima aplikasi sendiri.
Untuk mengakses integrasi:
Dalam hal menggunakan ChirpStack kami tertarik
Di kedua server, integrasi ini berfungsi dengan cara yang sama: meluncurkan acara setiap kali perangkat aplikasi mengirimkan informasi (dalam hal TTN kita harus menandai kotak pesan uplink ) dan, dengan informasi ini, postp permintaan http post -type diluncurkan ke URL yang kami tunjukkan.
Catatan: Praktik yang baik, baik untuk memverifikasi bahwa acara diluncurkan dengan benar atau untuk memvisualisasikan format data adalah untuk mengakses layanan postbin, di mana kami dapat membuat tempat sampah (URL sementara untuk menerima permintaan).
Catatan2: Jika aplikasi yang akan Anda luncurkan, petisi ditempatkan di LocalHost dan server ChirpStack juga (dengan cara dokerisasi seperti yang ditunjukkan dalam dokumentasi ini) Anda harus menunjukkan URL sebagai berikut:
http://host.docker.internal:PUERTO/uri
Dokumentasi ini hanya mencakup penggunaan ChirpStack dan TTN tidak didokumentasikan untuk mengirim data (ia memiliki format yang berbeda dalam petisi).
Jika data telah diterjemahkan dengan contoh repositori ini (folder Decoders-Integrations ), kami akan mendapatkan badan dalam permintaan yang mirip dengan yang berikut:
{
"applicationID": 0,
"applicationName": "Name",
"deviceName": "DeviceName",
"devEUI": "BYTES_EUI",
"txInfo": [Object object],
"adr": true,
"dr": 5,
"fCnt": 24,
"fPort": 1,
"data": "DATA_WITHOUT_DECODE",
"objectJSON": {
"data":"DATA_WITHOUT_DECODE==",
"decodedData":{
"humidity":37,"temperature":23
},
"message":"Informacion recibida del nodo"
},
"tags": [Object object],
"confirmedUplink": false,
"devAddr": "BYTES_DEV_ADDR"
}
ObjectJson adalah objek yang dikembalikan oleh fungsi dekoder kami.
Untuk membacanya, misalnya dalam aplikasi JavaScript akan cukup untuk melakukan sesuatu yang mirip dengan yang berikut (lebih lanjut dalam file /Decoders-Integrations/arduino_Chirpstack_Http_Integration.js )
const { deviceName, objectJSON, devAddr} = req.body;
var sensorData = JSON.parse(objectJSON);
//devAddr esta codificado!
var temperature = sensorData.decodedData.temperature;
var humidity = sensorData.decodedData.humidity;
Sebenarnya, kecuali kita menggunakan MQTTS (MQTT dengan TLS) tidak perlu mengakses integrasi apa pun dari aplikasi web server.
Dalam contoh ini kami akan menandatangani aplikasi kami ke topik yang akan dikirimkan oleh perangkat akhir kami.
Jika aplikasi kami diluncurkan di rumah dan server ChirpStack juga (berlabuh seperti yang telah kami tunjukkan dalam dokumentasi ini), host broker akan menjadi IP mesin WSL. Untuk mengetahui data ini, kami akan meluncurkan:
wsl hostname -I
Anda juga harus membuat beberapa konfigurasi dengan meluncurkan perintah berikut (1883 adalah port Mosquitto, jika modifikasi lain digunakan):
netsh interface portproxy add v4tov4 listenport=1883 listenaddress=0.0.0.0 connectport=1883 connectaddress=127.0.0.1
Kami dapat menggunakan MQTT karena hadir dalam contoh Docker, dengan parameter anonim dengan nilai Tru (tanpa menggunakan jenis kata sandi atau daftar pengguna apa pun) atau kami dapat mengonfigurasi daftar pengguna (masing -masing dengan topik yang dapat membaca atau menulis) dengan kata sandi masing -masing (seperti yang ditunjukkan oleh dokumentasi berikut).
Untuk melakukan ini, kami akan meluncurkan perintah berikut (kami dapat meluncurkannya dari WSL ), masing -masing akan meminta kami untuk memperkenalkan kata sandi untuk setiap pengguna (dalam contoh ini pass telah digunakan untuk semua):
# Create a password file, with users chirpstack_gw, chirpstack_ns, chirpstack_as, bob and nodeApp
sudo mosquitto_passwd -c /etc/mosquitto/passwd chirpstack_gw
sudo mosquitto_passwd /etc/mosquitto/passwd chirpstack_ns
sudo mosquitto_passwd /etc/mosquitto/passwd chirpstack_as
sudo mosquitto_passwd /etc/mosquitto/passwd bob
sudo mosquitto_passwd /etc/mosquitto/passwd nodeApp
# Optional, Secure the password file
sudo chmod 600 /etc/mosquitto/passwd
Ini akan membuat file passwd yang akan berisi semua pengguna dan kata sandi, kami sekarang dapat mengonfigurasi daftar ACLS dalam file homonim seperti berikut:
user chirpstack_gw
topic write gateway/+/event/+
topic read gateway/+/command/+
user chirpstackns
topic read gateway/+/event/+
topic write gateway/+/command/+
user chirpstack_as
topic write application/+/device/+/event/+
topic read application/+/device/+/command/+
user bob
topic read application/123/device/+/event/+
topic write application/123/device/+/command/+
user nodeApp
topic read application/+/device/#
topic write application/+/device/#
Sekarang, kita harus memodifikasi konfigurasi server untuk menggunakan kredensial ini dengan memodifikasi file yang diajukan di /chirpstack-docker/configuration :
[application_server.integration.mqtt]
server="tcp://mosquitto:1883"
username="chirpstack_as"
password="pass"
[integration.mqtt.auth.generic]
servers=["tcp://mosquitto:1883"]
username="chirpstack_gw"
password="pass"
[network_server.gateway.backend.mqtt]
server="tcp://mosquitto:1883"
username="chirpstack_ns"
password="pass"
listener 1883
password_file /mosquitto/config/passwd
acl_file /mosquitto/config/acls
allow_anonymous false
mosquitto:
image: eclipse-mosquitto:2
ports:
- 1883:1883
volumes:
- ./configuration/eclipse-mosquitto/mosquitto.conf:/mosquitto/config/mosquitto.conf
- ./configuration/eclipse-mosquitto/passwd:/mosquitto/config/passwd
- ./configuration/eclipse-mosquitto/acls:/mosquitto/config/acls
Dalam contoh ini kami akan menggunakan aplikasi NodeJS untuk terhubung ke server lokal ChirpStack lokal kami. Semua kode dapat ditemukan di file /Decoders-Integrations/arduino_Chirpstack_mqtt_Integration.js file.
Pertama, kita harus menginstal paket MQTT
npm install mqtt --save
Dengan dia, kita sudah bisa terhubung ke broker:
var mqtt = require('mqtt')
const host = 'WSL_IP'
const port = '1883' //or your port
const clientId = 'mqtt_NodeApp_' + Math.random().toString(16).slice(3)
const connectUrl = 'mqtt://' + host + ':' + port;
const client = mqtt.connect(connectUrl, {
clientId,
clean: true,
//username: "nodeApp", //Descomentar si usamos contraseñas y acls
//password: "pass", //Colocar el usuario y contraseña correspondiente
connectTimeout: 4000,
reconnectPeriod: 1000,
debug: true
})
Dan berlangganan topik yang diinginkan (karakter # adalah wildcard bertingkat, itu berarti bahwa kita membaca subtopian apa pun, sedangkan karakter + adalah wildcard tingkat tunggal).
const chirpstackApplicationID = 1; //Check url, for example: http://localhost:8080/#/organizations/1/applications. /1/ is the ID
const chirpstackDeviceID = "DEV_EUI";
const chirpstackReadAppTopic = "application/" + chirpstackApplicationID + "/device/#";
const chirpstackWriteAppTopic = "application/" + chirpstackApplicationID + "/device/"+chirpstackDeviceID+"/EXAMPLE";
Kami akan menggunakan acara berikut untuk ini:
//Evento al conectarse
client.on('connect', function () {
console.log("Connected")
client.subscribe(chirpstackReadAppTopic, function (err) {
if (!err) {
console.log("Subscribed to topic: "+chirpstackReadAppTopic)
//client.publish(chirpstackWriteAppTopic, 'Hello mqtt') //Podemso enviar un mensaje para debugear
}
else {
console.log("Error in connection:")
console.log(err)
}
})
})
//Evento al recibir un mensaje
client.on('message', function (topic, message) {
// El mensaje es un buffer, convertimos a String.
var stringMsg = message.toString();
console.log(topic + " - " + stringMsg)
insertSensorEntry_Mqtt(topic, stringMsg); //Funcion que lee el mensaje e inserta en base de datos
})
En ambos servidores (Chirpstack y The Things Network) la integración tiene por nombre MQTT , eso sí, antes de realizar ninguna integración debemos configurar los certificados.
A continuación se documentará como realizar la integración con MQTT en un servidor local de Chirpstack (para más info revisar el apartado ChirpStack privado en local de esta documentación).
Antes de generar los certificados, debemos tener instalado CFSSL & CFSSLJSON. Tras ello, clonaremos el siguiente repositorio propiedad del creador de Chirpstack y seguiremos los pasos de su documentación: Chirpstack-Certificates.
NOTA: Si se usa Windows, instalar los pre-requisitos en la máquina WSL pues se necesitará hacer uso del comando make .
Colocamos la carpeta certs generada con el proyecto Chirpstack-Certificates en nuestro proyecto Chirpstack-Docker . Después modificados el archivo docker-compose.yml para añadir a cada contenedor el volumen que contendrá los certificados correspondientes.
Seguimos siguiendo la documentación del proyecto Chirpstack-Certificates para realizar todas las modificaciones pertinentes en la configuración del servidor:
Como hemos visto anteriormente, el evento que se lanza al recibir un mensaje llama a una función que lee el mensaje recibido y lo descodifica.
El formato del mensaje recibido (si hemos usado los descodificadores del ejemplo) es una cadena de texto con el siguiente contenido:
{"applicationID":"1","applicationName":"APP_NAME","deviceName":"DEV_NAME","devEUI":"DEV_ADDRESS", "txInfo":{"frequency":868500000,"dr":5},"adr":true,"fCnt":2, "fPort":1,"data":"DATA","object":{"data":"DATA","decodedData":{"humidity":0,"temperature":-327},"message":"Informacion recibida del nodo"}}
Y es lo que buscamos leer en la siguiente función:
function insertSensorEntry_Mqtt(topic, msg){
console.log("INSERTAMOS DATO DE SENSOR RECIBIDO POR MQTT EN TOPICO: "+topic);
const parseMsg = JSON.parse(msg); //Recordar haber hecho un ToString al buffer antes!
var deviceName = parseMsg.deviceName;
var devAddr = parseMsg.devEUI; //No codificado
var temperature = parseMsg.object.decodedData.temperature;
var humidity = parseMsg.object.decodedData.humidity;
var success = true;
}
object es el objeto retornado por nuestra función Decoder .
Como bien se sabe, la tasa de transferencia de LoRA es muy baja, lo que provoca una gran perdida de paquetes y una enorme latencia cuando se envía información:
Algunos expertos indican que es necesario cierta distancia entre los dispositivos (30m y preferiblemente algún obstaculo entre ellos) para que la comunicación sea más fluida. No ha sido probado y solo se ha lanzado con las dos tarjetas en un extremo cada una de un piso.
Por otro lado se hace uso de versiones antiguas de LoRaWAN (1.0.2 y 1.0.3) que tienen problemas de seguridad que se solventan en parte en las siguientes versiones (1.0.4 y 1.1.0, esta última también implementa re-conectividad en caso de desconectarse de la red LoRaWAN), pero no se dispone de librerias para trabajar con ellas.
Esto no quita que esta técnología pueda ser muy interesante y útil en el futuro debido a no depender de proveedores externos (de comunicaciones y electricidad), siendo una opción ecónomica y muy llamativa para utilizar en proyectos IoT de grandes ciudades o entornos rurales.
Este proyecto ha sido realizado para la Fundación CTIC, su uso es libre y no es necesarío ningún crédito en su uso (Revisar las licencia de las librerias utilizadas).
