Vägövervakning: 15 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:45

Idag kommer vi att visa dig hur vi inrättade ett system för övervakning av vägavvikelser baserat på accelerometrar, LoRaWAN, Amazon Web Services och Google Cloud API.

Steg 1: Krav

• DISCO-L072CZ-LRWAN1-kort
• X-NUCLEO-IKS01A2 expansionsmodul (för accellerometer)
• X-NUCLEO-GNSS1A1 (för lokalisering)
• Ett AWS -konto
• Ett Google Cloud Platform -konto

Steg 2: Bygga och blinka sensorns firmware

Anslut IKS01A2 och GNSS1A1 ovanpå kortet genom GPIO -stiften. Ladda ner firmware -koden från GitHub. Skapa (om du inte redan har ett) ett konto på ARM Mbed och importera koden i repo på onlinekompilatorn. Ställ in målplattformen på DISCO-L072CZ-LRWAN1 och spara projektet. Gå nu till The Things Network och skapa ett konto om du inte redan har det. Skapa ett program, skapa en ny enhet inuti programmet och ställ in anslutningsläget till OTAA. Ta fram lämpliga parametrar för att fylla i följande fält i filen mbed_app.json: "lora.appskey", "lora.nwkskey", "lora.device-address".

Sensorn registrerar regelbundet accelerometer- och GNSS -data och skickar dem via LoRa -anslutningen till närmaste gateway, som skickar dem vidare till vår applikation på The Things Network. Nästa steg är att konfigurera en molnserver och en HTTP -integration på TTN.

Steg 3: Konfigurera molnet

Nu är vi redo att installera molninfrastrukturen som samlar in och sammanställer data från alla de utplacerade korten. Denna infrastruktur visas i figuren nedan och består av:

• Kinesis, för att hantera den inkommande dataströmmen;
• Lambda, för att filtrera och förbehandla data innan den lagras;
• S3, för att lagra all data;
• EC2, för att analysera data och att vara värd för vårt front-end.

Steg 4: Konfigurera AWS Lambda

Vi kommer att illustrera de steg som är nödvändiga för att skapa denna infrastruktur, med början från Lambda.

1. Logga in med ditt AWS -konto, och från konsolens huvudsida och gå till Lambda
2. Klicka på Skapa funktion
3. I den övre delen av sidan ska den väljas Author from Scratch. Fyll sedan i de andra fälten som på bilden och klicka sedan på Skapa funktion
4. Nu när du har skapat en AWS Lambda-funktion går du till https://github.com/roadteam/data-server och kopierar innehållet i filen aws_lambda.py till redigeraren som du hittar den andra halvan av sidan. Din Lambda -funktion är nu klar:)

Steg 5: Ställ in dataström för AWS Kinesis Firehose

1. Återgå nu till AWS -konsolens huvudsida och gå till Tjänster till Kinesis
2. Nu är du på huvudsidan för Kinesis. Till höger på sidan, under "Kinesis Firehose leveransströmmar", välj "Skapa ny leveransström"
3. I "Leveransströmnamn" skriver du "road-monitoring-stream". Lämna de andra fälten till standard och klicka på nästa
4. Nu under 'Transform source source records with AWS Lambda' välj Enabled, och som Lambda-funktion klickar du på den nyskapade 'road-monitoring-lambda'. Oroa dig inte om en varning om funktionstidsgränsen dyker upp, eftersom operationen som vi gör inte är beräkningsmässigt dyr. Lämna de andra fälten till standard och klicka på nästa
5. Som destination väljer du Amazon S3 och som S3 -destination väljer du Skapa nytt. Som hinknamn anger du "vägövervakning-hink" och går sedan. Lämna nu de andra fälten till standard och klicka på Nästa
6. Du kanske vill ange buffertstorlek till 1 MB och buffertintervall till 60 sekunder. Bufferten spolas till S3 när ett av de två villkoren är uppfyllt. Lämna inte sidan, se nästa steg

Steg 6: Ställ in IAM -roll för Kinesis

Nu ställer vi in säkerhetsbehörigheterna för Kinesis, eftersom den måste anropa Lambda -funktionen för förbehandling och sedan kommer den att skriva på S3

1. Längst ner på sidan som du är i "IAM -roll" väljer du "Skapa ny av val", skapar en ny IAM -roll som på bilden och klickar på Tillåt
2. Nu är du tillbaka till föregående sida, klicka på nästa. Nu kanske du vill dubbelkolla alla parametrar. Klicka på "Skapa leveransström" när du är klar

Kinesis-Lambda-S3-rörledningen är igång!

Steg 7: Konfigurera AWS EC2

Nu kommer vi att skapa en EC2 -instans med några API: er som gör det möjligt för oss att skjuta och dra data från AWS -molnet och även servern där vi kan vara värd för vår applikations frontend. I produktionsmiljö kanske du vill publicera API med den mer skalbara AWS API Gateway.

1. Från AWS -konsolens huvudsida går du till EC2 -tjänsten
2. Klicka på Launch Instance
3. I den övre sökfältet klistrar du in den här koden: 'ami-08935252a36e25f85', det vill säga den identifierande koden för den förkonfigurerade virtuella maskinen som ska användas. Klicka på Välj till höger
4. Välj t2.micro i kolumnen "Typ" och klicka på "Granska och starta". Starta inte instansen ännu, gå till nästa steg

Steg 8: Ställ in IAM -säkerhetsroll för EC2

1. Innan vi startar vill vi ändra säkerhetsgruppen för vår instans. För att göra detta, längst till höger i avsnittet "Säkerhetsgrupper" klickar du på "Redigera säkerhetsgrupper" Skapa en ny säkerhetsgrupp enligt följande. Detta konfigurerar i princip brandväggen för din instans som exponerar port 22 för SSH -anslutning och port 80 för http -tjänster
2. Klicka igen "Granska och starta". Kontrollera nu att alla parametrar är inställda. Klicka på Starta när du är klar
3. Vid klick kommer ett nytt fönster att dyka upp för att konfigurera ett nyckelpar för ssh -anslutning till instansen. Välj "Skapa nytt nyckelpar" och ange "ec2-road-monitoring" som namn. Klicka på Hämta nyckelpar. Det är oerhört viktigt att den här filen går vilse eller (värre) lagras osäkert: du kommer inte att kunna ladda ner nyckeln igen. När.pem -nyckeln har laddats ner är instansen redo att startas

Steg 9: Få åtkomst till din EC2 -instans

Din nya EC2 -instans finns i AWS -molnet. Du kan ansluta till den med nyckelfilen som laddades ner tidigare (för denna handledning antar vi att du känner till grunderna i ssh). Du kan hämta instansens IP genom att välja den i instrumentpanelen i avsnittet "Beskrivning" enligt följande: Du kan använda både din offentliga IP eller din offentliga DNS det är samma sak. Med en ssh -klient anger du nu kommandot:

ssh -i ec2-road-monitoring.pem ec2-user@DIN-IP-ADDR-ELLER-DNS

där ec2-road-monitoring.pem är din nyckel genererad tidigare.

Fortsätt nu med att dra koden på serversidan

git-klon-rekursiv

Steg 10: Hämta Google Maps API

Vi är nästan klara. Nu måste vi konfigurera Google maps API på vår html -sida för att kunna visa kartan med waypoints för användaren:

1. Logga in på ditt Google-konto och gå till
2. Klicka för att komma igång till vänster på sidan
3. Välj "Kartor" i menyn och klicka sedan på Fortsätt
4. Som projektnamn anger du "vägövervakning" och klickar på Nästa
5. Ange dina faktureringsuppgifter och klicka på Fortsätt
6. Nu är ditt projekt klart och vi kommer att få API -nyckeln genom att klicka på API: er och tjänster -> Credentials

Steg 11: Starta server

Och där är det din API -nyckel. Det sista du måste göra är att gå till data_visualization/anomalies_map.html och kopiera din nyckel till slutet av filen på det sättet och ersätta "DIN-KEY-HÄR"

Nu är allt klart och klart! För att den ska börja köra i EC2-instansen: 'cd-dataserver' 'python flask_app.py'

Ange ip eller dns -adressen för din EC2 -instans i din webbläsare, du bör se avvikelsekartan med några dummy -data

Steg 12: Utför HTTP -integration på Things Network

Nu när vi har all backend -infrastruktur igång kan vi bearbeta för att utföra HTTP -integrationen.

1. Skapa en ny applikation och registrera din enhet. Vi förutsätter grundläggande kunskaper om TTN, om inte referera till snabbstartguiden
2. Välj "Integrationer" i din programmeny och sedan "lägg till integration"
3. Välj HTTP -integration
4. Ange fälten efter bilden och ersätt med din EC2 ip eller offentliga DNS

Steg 13: Databehandling

För varje tuppel data T som samlas in från sensorn måste du utföra följande steg:

1. Få uppsättningen tupler som har GPS -koordinater som faller i lokalområdet T. Det lokala området är alla tupler som är 100 meter runt T.
2. För varje närmaste tupel N beräknas kvadratmedelvärdet för accelerometerns Z-axel i N. I pseudokod: medelvärde = summa [x. Z_accel ** 2 för x i nära]) / nära. Storlek
3. Beräkna den kvadrerade standardavvikelsen. I pseudokod: std = summa [(x. Z_accel ** 2 - medelvärde) ** 2 för x i nära]
4. Utmatning i detta format: lat, lång, Z_accel ** 2, medelvärde, std

Använd GPS -avståndet i meter för att beräkna det lokala området. I C ++:

#define D2R (M_PI / 180.0)

#define EARTH_RAY 6371 dubbel distans (dubbel lat1, dubbel lång1, dubbel lat2, dubbel lång2) {dubbel dlong = (long2 - long1) * D2R; dubbel dlat = (lat2 - lat1) * D2R; dubbel a = pow (sin (dlat/2.0), 2) + cos (lat1 * D2R) * cos (lat2 * D2R) * pow (sin (dlong/2.0), 2); dubbel c = 2 * atan2 (sqrt (a), sqrt (1-a));

Nu, med hjälp av de mellanliggande data som genererades i föregående steg, upptäck avvikelserna och gör en naiv klassificering med hjälp av detta klipp som tillämpas på varje rad:

line = map (float, line.split (","))

v = rad [2] medel = rad [3] std = rad [4] om v (medelvärde + std*3): om v (medelvärde + std*2): om v (medelvärde + std): o. lägg till ([1, rad [0], rad [1]) else: o.append ([2, rad [0], rad [1]) else: o.append ([3, rad [0], rad [1])

Avvikelserna klassificeras med 68–95–99.7 -regeln

Nu har du en samling med detta format [typ, lat, lång].

Typbetydelsen är följande:

1. Lite anomali, förmodligen irrelevant
2. Medium anomali
3. Kritisk anomali

Steg 14: Visualisering

För att förstå och kanske ändra visualiseringsdelen måste vi lära oss hur man använder anpassade markörer, en funktion i Google Maps API

För det första måste kartan initieras i ett återuppringning:

funktion initMap () {

data = queryData (); map = new google.maps. Map (document.getElementById ('map'), {zoom: 15, center: {lat: data [0] [1], lng: data [0] [2]}}); anmärkning(); }

Ange namnet på denna återuppringning i webbadressen (vi infogade här före vår API -nyckel) i en HTML -tagg:

script async defer src = "https://maps.googleapis.com/maps/api/js?key=[KEY]&callback=initMap"

En markör kan infogas i kartan när objektet skapas:

nya google.maps. Marker ({position: {lat: LATITUDE, lng: LONGITUDE}, map: map, ikon: “/path/to/icon.png”})

Du kan se i koden att för varje data i datamängden för anomalierna infogas en markör (se anmärkning () -funktionen) och ikonen är baserad på anomaliens klass. När vi kör detta i webbläsaren kan vi utforska en karta där avvikelser kan filtreras med kryssrutor, som visas på bilden.

Steg 15: Krediter och externa länkar

Detta projekt gjordes av Giovanni De Luca, Andrea Fioraldi och Pietro Spadaccino, första året civilingenjör i datavetenskapstudenter vid Sapienza universitet i Rom.

• Bilder som författarna använde för att presentera detta bevis på konceptet:

  www.slideshare.net/PietroSpadaccino/road-m…

• GitHub repos med hela koden:

  github.com/roadteam