Upload
others
View
2
Download
0
Embed Size (px)
Citation preview
SVEUČILIŠTE U ZAGREBU
FAKULTET ELEKTROTEHNIKE I RAČUNARSTVA
Zagreb, lipanj 2016.
ZAVRŠNI RAD br. 4417
SIMULACIJA JEDNOSTAVNIH STVARI ZA
PROVJERU MODELA ARHITEKTURE
INTERNETA STVARI
Antonio Brezjan
i
SADRŽAJ
1. Uvod ........................................................................................................................ 1
2. Internet stvari ........................................................................................................ 2
3. Arhitektura ............................................................................................................ 3
3.1. Format poruke .................................................................................................... 3
3.1.1. Zastavice ............................................................................................................... 4
3.2. Slanje poruke ...................................................................................................... 4
3.3. Primanje poruke ................................................................................................. 4
3.4. Zaštita podataka ................................................................................................. 6
3.4.1. Sigurni sažetak ...................................................................................................... 6
3.4.2. Kriptiranje ............................................................................................................. 6
4. Simulacija ............................................................................................................... 7
4.1. Pošiljatelj i primatelj 1 ....................................................................................... 7
4.2. Pošiljatelj i primatelj 2 ....................................................................................... 8
4.3. Pošiljatelj i primatelj 3 ....................................................................................... 8
4.4. Pošiljatelj i primatelj 4 ....................................................................................... 9
4.5. Simulacija sa složenim simulatorom ................................................................ 10
4.5.1. Pokretanje simulacije .......................................................................................... 10
4.5.2. Rezultati .............................................................................................................. 10
5. Zaključak ............................................................................................................. 12
Literatura ...................................................................................................................... 13
Sažetak ........................................................................................................................... 14
Summary ........................................................................................................................ 14
1
1. UVOD
U današnje vrijeme koristi se mnogo elektroničkih naprava koje sadrže ugradbena
računala. Povezivanje tih stvari je logičan korak naprijed, ali se nailazi na problem kako
će te stvari međusobno komunicirati. Ta mreža se naziva Internet stvari (eng. Internet of
Things) i u ovom dokumentu će se ostvariti simulacija na temelju koje bi te stvari mogle
međusobno komunicirati.
Da bi se ostvarila simulaciju prvo se kratko definira arhitekturu Interneta stvari.
Najjednostavnija stvar može biti neki senzor koji samo šalje podatke. Takva stvar treba
samo znati adresu kamo će te podatke slati i šalje ih po nekom pravilu (npr. svakih
nekoliko minuta). Takvoj stvari možda nije ni bitno da li odredište primi svaku poruku te
je za takvu stvar dovoljno samo osigurati slanje podatka.
Paralelno s jednostavnim pošiljateljem razvijamo jednostavnog primatelja koji samo
prima podatke i može nad njima obaviti nešto. Najčešće neki izvršitelj izvede neku
jednostavnu radnju na temelju ulaza.
Iako mnoge stvari služe za te jednostavne radnje, najčešće želimo znati da li je odredište
primilo našu poruku. Iz tog razloga spajamo funkcije za slanje i primanje podataka i
dobivamo stvar koja može slati podatak i primati odgovor ili potvrdu da je odredište tu
poruku i dobilo. S druge strane potrebna nam je stvar koja će moći sukladno o dobivenoj
poruci poslati odgovor.
Da spriječimo zlouporabu podataka uvodimo i mehanizme zaštite, sigurni sažetak i
kriptiranje podataka. Malo po malo složenost stvari se povećava, ali u svim slučajevima
stvari znaju kako komunicirati međusobno i ne mijenjamo sastav poruke kojom
komuniciramo nego samo proširujemo postojeći način komunikacije.
2
2. INTERNET STVARI
Definicija Interneta stvari (IS) varira između kompanija koje se bave njezinom
implementacijom. Internet stvari možemo opisati kao sustav koji se bavi povezivanjem
stvari koje je moguće jedinstveno identificirati. Riječ stvar odnosi se na bilo koji fizički
objekt koji koristi neka aplikacija ili korisnik izravno. Stvar je priključena na svoju mrežu
i njena sveprisutnost je glavna značajka sustava. Pošto su stvari umrežene lako ih
koristimo preko Interneta ili u našoj lokalnoj mreži kada je to potrebno. Veliki dio tih
stvari čine jednostavni senzori i upravljačke stvari koje same mogu izvršavati svoju
zadaću s obzirom na parametre u mreži. Opseg sustava Interneta stvari može biti od malog
sustava koji ima jedinstvenu stvar i jednostavni senzor do kompleksnog sustava koji
povezuje velik broj stvari i ima sposobnost isporučivanja kompleksnih usluga.
IEEE je Internet stvari podjelio na jednostavne i složene i uveo dvije definicije. Prva
definicija za Internet stvari jednostavne složenosti je da je to mreža koja povezuje
jedinstveno identificirane stvari na internetu. Stvari imaju senzorski aktivirane i
potencijalno programirljive sposobnosti. Podaci o stvari se mogu prikupljati i stanje stvari
se može mijenjati s bilo kojeg mjesta, u bilo koje vrijeme, u vezi bilo čega.
Druga definicija gleda na Internet stvari kao samoodrživu, prilagodljivu, složenu mrežu
koja povezuje stvari na internetu kroz korištenje standardnih komunikacijskih protokola.
Stvari nude usluge, sa ili bez ljudskih intervencija, prikupljanja podataka, komunikacije i
korištenje inteligentnih sučelja. To nam omogućuje brzu komunikaciju s pravim
podacima bilo gdje, u bilo koje vrijeme, u vezi bilo čega uzimajući u obzir sigurnost.
Detaljnije o definiciji Interneta stvari nalazi se u literaturi [1].
Slika 2.1. Značajke i opseg Interneta stvari
3
3. ARHITEKTURA
Internet stvari (IS) čine mnoge naprave kao što su senzori, uređaji, korisnici i servisi u
oblaku. Stvari koje komuniciraju nazivamo pošiljatelj (stvar koja šalje podatke) i
primatelj (stvar koja podatke prima). U složenijim sustavima nailazimo i na posrednika,
jednog ili više, koji samo prosljeđuje poruke između pošiljatelja i primatelja. U ovoj
simulaciji jednostavnih stvari komunikacija se odvija samo između primatelja i
pošiljatelja.
Prvo je potrebno definirati svojstva koja su potrebna da bi mogli neku stvar promatrati
kao potencijalni dio Interneta stvari. Stvari razlikujemo po njezinim imenima i
identifikatorima. Dok ime ne mora biti jedinstveno za određenu stvar očekuje se da njezin
identifikator točno određuje promatranu stvar. Stvari imaju i svoje unutarnje ključeve
preko koje se generira javni ključ i dekriptiraju podaci ako su kriptirani. Stvar u mreži
ima svoju adresu preko koje druge stvari komuniciraju s njom i tablicu s podacima o
drugim stvarima oko nje. Ta tablica sadrži identifikatore okolnih stvari, njihove javne
ključeve i adrese.
Osim gore navedenih zahtjeva potrebno je definirati i format poruke (paketa) kojim će
stvari moći razmjenjivati podatke.
3.1. Format poruke
Poruka koju šaljemo može biti unutarnja poruka s omotačem ili samo unutarnja poruka.
U ovom slučaju se koristi samo unutarnja poruka koja se sastoji od nekoliko dijelova
navedenih u tablici (Tablica 3.1.).
Tablica 3.1. Dijelovi poruke
Zastavice su objašnjene u poglavlju 3.1.1.
Duljina se odnosi na ukupnu duljinu poruke i mjeri se u oktetima. Za prikaz duljine koristi
se 16 bita čija vrijednost ograničava ukupnu duljinu poruke na 65535 okteta. Za velik dio
stvari duljina poruke je i više nego dovoljna, a ona ovisi o kompleksnosti same stvari.
Identifikatori služe za jasno razlikovanje poruka, pošiljatelja i primatelja. Identifikator
poruke se generira odmah prilikom slanja poruke dok su identifikatori stvari unaprijed
poznate i nisu podložne promjenama. Identifikator prijašnje poruke koristimo samo kada
šaljemo odgovor na primljenu poruku i on je jednak identifikatoru poruke za koju šaljemo
odgovor.
Naziv dijela poruke Oznaka Duljina dijela u
oktetima Obavezno
Zastavice flags 2 da
Duljina length 2 da
Identifikator poruke mid 8 da
Identifikator pošiljatelja src 8 da
Identifikator primatelja dest 8 da
Identifikator prijašnje poruke resp 8 ne
Podaci data 0-X ne
Siguran sažetak hmac 4 ne
4
Podaci su sami razlog slanja poruke i njihova duljina ovisi o broju koji se nalazi u dijelu
poruke duljina. Maksimalna duljina podataka u poruci ovisi o veličini paketa koju koristi
transportni protokol preko kojeg šaljemo poruku umanjenu za veličinu ostalih dijelova
poruke. Podaci se mogu slati u izvornom obliku, da primatelj direktno može čitati podatke
ili su podaci kriptirani. Na kraju poruke, ako je definirano unutar same stvari, nalazi se
sigurni sažetak. Duljine je 4 okteta i izračunava se nad cijelom porukom.
3.1.1. Zastavice
Zastavicama označavamo unaprijed definirana pravila. Naša poruka može definirati 16
pravila postavljanjem odgovarajućih bitova na pravo mjesto. U našoj simulaciji koristimo
samo jedan dio zastavica dok se druge koriste u složenoj komunikaciji ili nisu još
definirane.
Tablica 3.2. Zastavice
3.2. Slanje poruke
Za slanje poruke potrebno je znati identifikator primatelja i njegovu adresu. Ako nam je
poznata adresa primatelja počinjemo sa sastavljanjem poruke. Ovisno o složenosti poruke
koju želimo poslati postavljamo potrebne zastavice, generiramo identifikator poruke i
unosimo podatke koje želimo poslati. Po potrebi poruci dodajemo siguran sažetak i
kriptiramo poruku. Siguran sažetak i kriptiranje možemo izvršiti samo ako nam je poznat
vanjski ključ primatelja. U kodu (Isječak koda 3.1.) se slanje obavlja izvođenjem funkcije
pod nazivom send(...) s odgovarajućim parametrima.
3.3. Primanje poruke
Nakon što primatelj primi poruku on kreće sa njenom obradom. Prvo pročita zastavice,
duljinu poruke i identifikatore poruke, pošiljatelja i odredišta. Zatim ako je u zastavicama
postavljen bit za siguran sažetak poruke radimo novi sigurni sažetak na temelju primljene
poruke da vidimo da li se naš sigurni sažetak podudara sa dobivenim. Ako se podudara
poruku prihvaćamo i dekriptiramo ako je potrebno, a ako se razlikuju poruku
odbacujemo. Nakon primanja poruke možemo poslati odgovor stvari od koje smo dobili
odgovor kao potvrdu da smo primili poruku. U tom slučaju u poruku postavljamo
zastavicu RESP_SET i u poruci šaljemo identifikator prijašnje poruke koji je isti
identifikatoru poruke na koju šaljemo potvrdu o primitku poruke. Primljenu poruku
obrađujemo funkcijom recv()(Isječak koda 3.2.).
Naziv zastavice Binarna
vrijednost Opis u slučaju da je zastavica postavljena
RESP_SET 10000 U poruci se nalazi identifikator prijašnje poruke
DATA_SET 100000 U poruci postoje podaci
ENCRYPTED 1000000 Poruka je kriptirana
HMAC_SET 10000000 Poruka sadrži siguran sažetak
5
Isječak koda 3.1. Pošiljatelj
from Crypto import Random
import socket
import random
import binascii
import time
import sys
# flags for inner packet
DATA_SET = 1<<5
LOCAL_ADDRESS = ('127.0.0.1', 10000)
REMOTE_ADDRESS = ('127.0.0.1', 50000)
SRC_ID = 0x1111111111111111
DEST_ID = 0x2222222222222222
DATA_PREFIX = 'Kolicina padalina u zadnjih 24h: '
MSG_LEN = 2+2+8+8+8
flags = DATA_SET
src = SRC_ID.to_bytes(8, 'big')
dest = DEST_ID.to_bytes(8, 'big')
def send ( dest_id, data ):
mid=Random.new().read(8)
length=MSG_LEN+len(data)
message=flags.to_bytes(2, 'little')+length.to_bytes(2,\
'little')+mid+src+dest_id+data
sock.sendto(message, REMOTE_ADDRESS)
if __name__ == "__main__":
sock=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(LOCAL_ADDRESS)
while True:
#stvori podatak
attr=random.randrange(10000)
msg=(DATA_PREFIX + str(attr)).encode()
send ( dest, msg )
time.sleep(1)
Isječak koda 3.2. Primatelj
from Crypto import Random
import socket
import random
import time
import binascii
from struct import *
# flags for inner packet
LOCAL_ADDRESS = ('127.0.0.1', 50000)
def recv ():
packet, src_addr = sock.recvfrom (15000)
flags = packet[0] + (packet[1]<<8)
6
length = packet[2] + (packet[3]<<8)
mid = packet[4:12]
src = packet[12:20]
dest = packet[20:28]
data = packet[28:]
return ( flags, length, mid, src, dest, data )
if __name__ == "__main__":
sock=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(LOCAL_ADDRESS)
sock.settimeout(1)
while True:
try:
msg = recv()
except:
pass
time.sleep(1)
3.4. Zaštita podataka
Kako bi se zaštitili od pregledavanja i zlouporabe podataka koje šaljemo potrebno je
podatke zaštititi. U ovoj simulaciji štitimo se korištenjem sigurnog sažetka poruke i
kriptiranjem podataka u poruci.
3.4.1. Sigurni sažetak
Sigurni sažetak je ključ koji se računa HMAC (eng. keyed-hash message authentication
code) algoritmom [2]. HMAC koristi ključ koji je poznat pošiljatelju i primatelju i hash
funkciju MD5 za izračunavanje našeg sigurnog sažetka. U našem slučaju sigurni sažetak
se radi nad cijelom porukom od zastavica do podataka (vidi poglavlje 3.1. Format
poruke).
Sigurni sažetak se koristi za osiguravanje i provjeru autentičnosti poruke. Sigurni sažetak
ne štiti podatke od čitanja već osigurava da nepromijenjeni stignu na odredište. Ukoliko
se poslani sigurni sažetak ne podudara sa sigurnim sažetkom na odredištu poruku
odbacujemo jer ne možemo potvrditi da je ona autentična originalnoj poruci. Sigurni
sažetak se dobiva pozivom funkcije get_hmac(message, key)kojoj šaljemo poruku
za koju želimo sažetak i ključ po kojem računamo sažetak.
3.4.2. Kriptiranje
Kriptiranje služi za zaštitu podataka koje šaljemo kroz mrežu od neovlaštenog čitanja.
Podaci se kriptiraju tako da pošiljatelj kriptira podatke javnim ključem primatelja. Za
dekriptiranje tog podatka je potreban drugi ključ kojeg zna samo primatelj tako da
podatke namijenjene primatelju nitko drugi ne može pročitati.
7
4. SIMULACIJA
Simulacija je izvedena na Windows operacijskom sustavu preko Anaconda 2.4.1 prozora
naredbenog retka, korištenjem Pythona 3.5.1. Sva dokumentacija vezana uz Python se
može pronaći na referenci [4].
Simulator dijelimo na pošiljatelja i primatelja i svaki ima četiri verzije koje mogu
međusobno komunicirati. Za prijenos poruka koristi se UDP (engl. User Datagram
Protocol), no isto tako može se koristiti neki drugi protokol za prijenos podataka.
Pokretanje simulacije vršimo tako da otvorimo dva prozora naredbenog retka i u jednom
pokrenemo pošiljatelja, a u drugom primatelja. Nakon pokretanja ispisuju se poruke koje
su poslane i primljene u svakoj stvari koju simuliramo. Za lakše razlikovanje primatelja
od pošiljatelja, pod identifikatorom primatelja koristimo „111111111111111“, dok za
identifikator primatelja koristimo „2222222222222222“. Svaka stvar se pokreće
upisivanjem naredbe u naredbeni redak.
python naziv_stvari.py
Prije upisivanja ove naredbe moramo se pozicionirati u mapu koja sadrži stvar koju
želimo simulirati, a naziv_stvari je ime python datoteke koja predstavlja željenu stvar.
4.1. Pošiljatelj i primatelj 1
U prvoj simulaciji pošiljatelj generira podatak te ga priprema za slanje. Nakon
uspješnog slanja poruke primatelj otvara poruku i čita dobiveni podatak. Na slikama
(Slika 4.1.) i (Slika 4.2.) vidimo da smo za četiri poslane poruke primili četiri poruke na
izlazu što smo i očekivali.
Slika 4.1. Pošiljatelj 1
Slika 4.2. Primatelj 1
8
Ispis podataka ide redom kako je definirano u zadnjoj poruci:
zastavice: 32 u dekadskom je 100000 u binarnom što znači da je postavljena
zastavica DATA_SET što znači da poruka sadrži podatke,
duljina: poruka ima 65 okteta,
zatim imamo redom identifikatore poruke, pošiljatelja i primatelja,
na kraju se ispisuju podaci koji su primljeni
4.2. Pošiljatelj i primatelj 2
U ovom slučaju pošiljatelj (Slika 4.3.) šalje poruku isto kao u prethodnom slučaju, ali
nakon što je poruka poslana vidimo da je primio odgovor od primatelja. Poruka koja je
poslana kao potvrda da je primljena poruka ima poslije identifikatora za odredište i
identifikator prijašnje poruke na koju je poslala odgovor. Osim po identifikatoru vidimo
da je i zastavica drugačija. 48 dekadski iznosi 110000 binarno što znači da su postavljene
zastavice koje označavaju da imamo identifikator prijašnje poruke i podatke u poruci.
Slika 4.3. Pošiljatelj 2
Slika 4.4. Primatelj 2
4.3. Pošiljatelj i primatelj 3
U ovom primjeru uvodimo siguran sažetak. Kao što je opisano u poglavlju 3.4.1 ako se
sigurni sažetak u poruci ne podudara sa sigurnim sažetkom kojeg izračuna primatelj
poruka se ne smatra sigurnom te se odbacuje. U ovom slučaju je očekivani ispis isti kao
i u prethodnom slučaju, no ako se ključevi ne podudaraju dolazi do greške (Slika 4.6.) i
poruka se ne ispisuje.
9
Slika 4.5. Pošiljatelj 3
Slika 4.6. Primatelj 3
4.4. Pošiljatelj i primatelj 4
U ovom slučaju koristimo sve mogućnosti kao i gore osim što dodajemo i kriptiranje
podataka. Pošto ispis u slučaju dobre komunikacije izgleda kao u primjeru 2, neka
pošiljatelj ima krivi ključ za kodiranje. Kada usporedimo podatke koji su poslani (Slika
4.7.) i podatke koji su primljeni (slika 4.8.) vidimo da se ne podudaraju. To znači da ako
netko otvori podatke koji nisu namijenjeni za njega neće ih moći pročitati jer ne zna ključ
za njihovo dekriptiranje.
Slika 4.7. Pošiljatelj 4
10
Slika 4.8. Primatelj 4
4.5. Simulacija sa složenim simulatorom
Osim simulacije komunikacije između ovih jednostavnih stvari, možemo i simulirati
komunikaciju ovih stvari s složenim simulatorom dostupnim na stranici
github.com/l30nard0/dasiot [3].
Nakon dohvata programa s navedene stranice može se simulirati tijek komunikacije
između složenog sustava i neke od prije navedenih stvari. Za simulaciju se može koristiti
prozor naredbenog retka Anakonda kod Windows operacijskog sustava ili obični prozor
naredbenog retka u Linux operacijskom sustavu.
4.5.1. Pokretanje simulacije
Za pokretanje komunikacije između jednostavne stvari i složenog simulatora potrebno je
konfigurirati složeni simulator. U svakoj mapi gdje se nalazi jednostavna stvar nalaze se
dvije JSON datoteke koje definiraju ponašanje složenog simulatora. Za jednostavniju
simulaciju mape sa stvarima se kopiraju u datoteku gdje se nalaze ispitni slučajevi
složenog simulatora dasiot-master\tests\.
Složeni simulator se pokreće naredbom:
python src\sim.py tests tc-xx
Prije pozivanja naredbe moramo biti pozicionirani u mapi dasiot-master, a tc-xx
označava naziv mape u kojoj je stvar koju želimo testirati. Jednostavnu stvar pokrećemo
kao i u prethodnim primjerima.
4.5.2. Rezultati
Ispravnim definiranjem stvari i simulatora dobivamo rezultate slične kao u prethodnim
primjerima. Za svaku poruku poslanu ili primljenu ispisujemo njezine podatke koje onda
možemo promatrati kako komuniciraju i usporediti da li dolazi do promjene u podacima.
Mijenjanjem adrese ili korištenje krivog ključa za izračunavanje sigurnog sažetka ili
kriptiranja dolazi do očekivanih grešaka u komunikaciji što nam očekivano javlja i sam
simulator.
Pokretanjem složenog simulatora i pošiljatelja 4 vidimo da su uspješno proveli
komunikaciju. Zastavice iznose 224 u dekadskom, odnosno E0 u heksadekadskom
sustavu i kada ta dva broja pretvorimo u binarni dobijemo 11100000. Po tome
zaključujemo da je poruka sadržavala podatke koji su bili kriptirani i također je imala
sigurni sažetak. Kako je poruka na primatelju, kojeg u ovom slučaju predstavlja složeni
simulator, jednaka poruci koja je poslana možemo zaključiti da se komunikacija uspješno
obavila.
11
Slika 4.9. Pošiljatelj 4
Slika 4.10. Složeni simulator konfiguriran za komuniciranje s pošiljateljem 4
12
5. ZAKLJUČAK
U radu je ukratko opisano što je to Internet stvari. Zbog opširnosti tog pojma i njegove
same izvedbe još nije standardom propisana njegova izvedba. Ovaj rad simulira moguću
komunikaciju između dvije jednostavne stvari. Teži se što jednostavnijoj komunikaciji,
ali da ujedno bude što univerzalnija i primjenjiva u složenijim sustavima
nadograđivanjem iste, a ne ponovnim razvijanjem za složenije sustave.
Nakon provedbe uspješne simulacije komunikacije s definiranim parametrima prikazana
je složenost i veličina koda koja bi trebala biti izvediva u stvarima ograničene memorije
i snage procesora. Smanjivanjem duljine poruke smanjujemo i gušenje mreže koja se sa
svakom i najmanjom stvari može vrlo brzo povećati.
U budućnosti ovaj se simulator može proširiti da obuhvati i složenije primjere
komunikacije i sve povezati u program za kojeg nije potrebno poznavanje skriptnog
jezika Python nego bi se stanja u mreži koju želimo simulirati mijenjala preko korisničkog
sučelja.
13
LITERATURA
1. IEEE, The Institute, Towards a definition of the Internet of Things (IoT),
http://iot.ieee.org/images/files/pdf/IEEE_IoT_Towards_Definition_Internet_of_Thi
ngs_Revision1_27MAY15.pdf, 8. 6. 2016.
2. H. Krawczyk, M. Bellare, R. Canetti, Keyed-Hashing for Message Authentication,
Veljača 1997, https://tools.ietf.org/html/rfc2104.html, 8. 6. 2016.
3. Leonardo Jelenković, Simulator used for designing and simulating Internet of things
architecture, https://www.github.com/l30nard0/dasiot, 5. 6. 2016.
4. The Python Software Foundation, Python 3.5.1 documentation,
https://docs.python.org/3/, 5.6. 2016.
14
SAŽETAK
Simulacija jednostavnih stvari za provjeru modela arhitekture Interneta stvari
Ovaj završni rad vezan je uz problem arhitekture povezivanja Interneta stvari. Glavna
značajka mu je simulacija komunikacije jednostavnih stvari s mogućnošću proširenja na
složenije stvari. Pod jednostavnim stvarima smatramo one uređaje kojima je osnovno
svojstvo samo slanje i primanje podataka te jednostavna obrada istih. Za potrebe
simulacije definirana je arhitektura koja bi trebala postojati za mogućnost te
komunikacije. Također su opisani neki očekivani izlazi simulatora kao i oni koji se mogu
dogoditi kod grešaka u sustavu.
Ključne riječi: Internet stvari, simulacija, arhitektura IS
SUMMARY
Simulating simple things for Internet of Things architecture verification
This bachelor thesis is related to the problem of architecture of the Internet of Things.
The main feature is a simulation of communication between simple things with the
possibility of extension to more complex things. Simple things are those devices which
main job is to send and receive data and using it in simple actions. It also defines
architecture that should exist for such communication. After defining described simulator
there are some of the expected outputs of simulations as well as those that can occur with
errors in the system.
Keywords: Internet of Things, simulation, IoT architecture