Mijn motortelemetrie

Over dit project

Elke keer dat ik een nieuw project start, probeer ik iets te creëren waarbij ik gebruik maak van de nieuwste technologieën die verband houden met mijn passies. Voor dit project besluit ik mijn passie voor de motor te combineren met mijn favoriete hobby (gebruik de Arduino).

Het idee

Ik ben altijd gefascineerd geweest door de telemetrische beelden die ik op tv zie over motogp-races. Toen ik afbeeldingen zoals hieronder zag, stelde ik me voor hoe ik het kon bouwen met mijn favoriete gadget (Arduino) en mijn programmeerkennis.

Dus besloot ik een telemetriesysteem te ontwikkelen op basis van Arduino en Azure, dat gemakkelijk te repliceren was, zodat alle motorliefhebbers er een in hun motor kunnen hebben.

Zoals hieronder zal worden getoond, kan dit telemetriesysteem de volgende informatie over uw rijstijl verkrijgen:

• Snelheid [km/u]

• GPS-positie (breedtegraad/lengtegraad)

• Satellietinformatie (Sat-nummer, Hdop)

• Hoogte [meter]

• Lean-hoek

• Wheeliehoek

• G Versnelling in de 3 assen [m/s^2]

• Externe temperatuur [°C]

• Temperatuur achterband [°C]

• Schokdemper voor [cm]

• Schokdemper achter [cm]

Daarvoor gebruikte ik een Arduino Uno R3, enkele sensoren, een UWP geïmplementeerd in een Windows Phone en enkele Azure-services.

De workflow wordt beschreven in de volgende afbeelding:

• Fase 1 - Alle telemetriegegevens worden verkregen van de regeleenheid ongeveer twee keer per seconde (de bedieningseenheid bevindt zich op de motor).

• Fase 2 - Elke keer dat de gegevens worden verkregen, worden de gegevens verzonden via bluetooth van Arduino naar Windows Phone .

• Fase 3 - De gegevens worden weergegeven in de telefoon (lees voor meer details het gedeelte 'Software') en vervolgens via het 3G/4G-netwerk verzonden naar Azure IoT HUB .

• Fase 4 - Op azure is er een Stream Analytics Job die de gegevens van de IoT HUB ontvangt en de informatie opslaat in een SQL Azure-database.

• Fase 5 - Op Azure is een WebApp . geïmplementeerd die de SQL-databasegegevens gebruiken om de telemetriegegevens in realtime weer te geven (lees de sectie Web App)

• Fase 6 - De WebApp , maakt gebruik van een authenticatieproces en toont alle telemetrie-informatie in grafieken. (Alle gegevens worden opgehaald uit sql Azure-database met behulp van Entity Framework)

• Fase 7 - Alle gegevens die zijn opgeslagen in de SQL Azure-database worden verwerkt door een Machine Learning om informatie over uw "rijstijl" op te halen. De scope zal zijn om te begrijpen hoe u uw rijstijl kunt aanpassen in functie van de telemetrieparameters om uw rijprestaties te verbeteren.

Ik vind het VRIJ COOL!!! Laten we beginnen met het beschrijven van het project

Hardware-installatie

Mijn hardwareconfiguratie wordt hieronder weergegeven.

Mijn hardwareconfiguratie bestaat uit:

• 1 x Arduino Uno R3

• 2 x Ultrasone bereikmodule HC-SR04 , Wordt gebruikt om de verlenging van de schokdemper te bepalen (voor en achter)

• 1 x infrarood thermozuil contactloze temperatuursensor TMP006, gebruikt om de bandentemperatuur te bepalen (kan de buitentemperatuur ook verkeerd inschatten - optioneel)

• 1 x GPS-NEO7M , gebruikt om de GPS-positie, snelheid, hoogte te bepalen

• 1 x ADXL345 , Wordt gebruikt om de G-versnelling in 3 assen te evalueren en de hellingshoek en de wielhoek te berekenen

• 1 x LM35DT om de externe temperatuur te bepalen

• 1 x HC-05 , bluetooth-module, om te communiceren tussen arduino en de Windows Phone

• 1 x Voeding (algemene batterij of mobiele powerbank )

STAP 1 - Bluetooth-connectiviteit

Ik gebruikte de SoftwareSerial bibliotheek om de bluetooth-module met de Arduino te verbinden en de draadloze communicatie met de Windows Phone mogelijk te maken.

Een HC-05 Voor deze scope is gekozen voor Bluetooth-module. Het is een klasse-2 Bluetooth-module met een serieel poortprofiel, die kan worden geconfigureerd als master of slave.

De volgende stap was om de standaardnaam van mijn Bluetooth-apparaat te wijzigen, de standaardnaam was HC-05 ... het was niet "aantrekkelijk"

Hoe dit apparaat te gebruiken:

In je Arduino-code:

• voeg de SoftwareSerial . toe bibliotheek

• definieer de RX/TX-poort

• inizialiseer de communicatie:

#include [...]SoftwareSerial BTSerial(10,11); // RX-TX[...]void setup(){BTSerial.begin(9600);[...]} 

U bent nu klaar om via Bluetooth elke gewenste string te verzenden met behulp van de volgende opdrachtregel:

...BTSerial.print("Hallo Hackster");... 

De communicatie tussen Windows Phone en Arduino is nu klaar en het was heel gemakkelijk!

STAP 2 - GPS-communicatie

De hardware die voor deze scope is gebruikt is een GPS-NEO7M module, het is een GPS-module met laag vermogen die 56 kanalen heeft en nauwkeurige positie-updates uitvoert bij 10 Hz.

De communicatie tussen Arduino en de GPS-module is gemaakt door de SoftwareSerial Bibliotheek en exploiteren van een zeer interessante bibliotheek genaamd TinyGPS++

Communiceren met deze sensor:

• Definieer de RX/TX-poort

• het TinyGPS-object initialiseren

• de communicatie initialiseren

Zie de onderstaande code:

#include #include // Definieer seriële verbinding met de GPSSoftwareSerial ss(12,13); // RX-TX// Definieer een TinyGPS ObjectTinyGPSPlus gps;void setup(){// GPS Inizializess.begin(9600);[...]}void loop(){// Terwijl GPS beschikbaar is, lees de informatie terwijl(ss) .available()>0){if(gps.encode(ss.read())){if(gps.location.isValid()){double lat=gps.location.lat();double lon=gps.location .lng(); }}}[...]} 

STAP 3 - Versnellingsmeter

Om de versnellingswaarden in de 3 assen te bepalen en voor het berekenen van de rol- en hellingshoek (lean- en wheelie-hoek), heb ik een ADXL345 gebruikt

De ADXL345 is een kleine, dunne, ultralaag vermogen, 3-assige accelerometer met hoge resolutie (13-bits) meting tot ±16 g. Digitale uitvoergegevens zijn geformatteerd als 16-bits twos-complement en zijn toegankelijk via een SPI (3- of 4-draads) of I2C digitale interface.

De communicatie tussen Arduino en de ADXL345-sensor gebeurt met behulp van de ADXL345.h Bibliotheek.

Het is erg belangrijk om te begrijpen dat wanneer u deze sensor aansluit, u de zwaartekrachtversnelling in de 3 assen kunt bepalen, maar de waarden worden niet onmiddellijk gekalibreerd. U moet een code aanmaken om de OFFSET in te stellen.

Ik besloot om het "nulpunt" in de eerste lus te bepalen. Om dat te doen, zal de G-versnelling in de eerste lus de referentiewaarden zijn die u moet aftrekken van de volgende metingen.

// eerste lus naar if (i ==0) {refXg =Xg; refYg =Yg; refZg =Zg;i =1;}// trek het nulpunt afXg =Xg - refXg;Yg =Yg - refYg;Zg =Zg - refZg + 1; 

Vervolgens moet u de hellingshoek en de wielhoek berekenen op basis van de g-versnellingscomponenten.

Hieronder zie je de 2 simpele wiskundige vergelijkingen om dat te doen:

// Roll &Pitch Vergelijkingenroll =-(atan2(-fYg, fZg) * 180.0) / M_PI; toonhoogte =(atan2(fXg, sqrt(fYg * fYg + fZg * fZg)) * 180,0) / M_PI; 

In dit project moet je rekening houden met:

• Z-as zijn de natuurlijke zwaartekrachtassen

• Y-as is de richting van de beweging

• X-as is de laterale beweging

Communiceren met deze sensor:

• het ADXL345-object initialiseren

• de communicatie initialiseren

Nu bent u klaar om de acceleratie-informatie te lezen, zie de onderstaande code:

#include #include #include // Definieer seriële verbinding met de GPSSoftwareSerial ss(12,13); // RX-TX// Definieer een ADXL345 ObjectADXL345 acc;void setup(){// ADXL345 Inizializeacc.begin();[...]}void loop(){// Lees g versnellingscomponenten dubbel Xg,Yg,Zg; acc.read(&Xg,&Yg,&Zg);} 

STAP 4 - Bandentemperatuur

Om de bandentemperatuur te bepalen had ik een sensor nodig die om voor de hand liggende redenen de band niet raakt. de unieke manier was om een ​​infrarood temperatuursensor te gebruiken. Om dat te doen heb ik besloten om een ​​TMP006 . te gebruiken sensor

De TMP006 zijn volledig geïntegreerde MEM's thermozuilsensoren die de temperatuur van een object meten zonder direct contact te hoeven maken. De thermozuil absorbeert passieve infraroodenergie van een object met een golflengte tussen 4 um tot 16 um binnen het door de eindgebruiker gedefinieerde gezichtsveld.

De corresponderende spanningsverandering over de thermozuil wordt gedigitaliseerd en gerapporteerd met de meting van de thermische sensor op de chip via een I2C

Nu is de vraag, waar moet ik mijn sensor plaatsen? Als u de datasheet bekijkt, kunt u belangrijke informatie vinden over de aanbevolen afstand tussen sensor en object.

U moet de regel in acht nemen dat de afstand kleiner moet zijn dan de halve straal van de ruimtehoek van het object.

met andere woorden, mijn bandbreedte is 160 mm, de halve breedte is de straal (R) van de ruimtehoek, dus het uiteindelijke resultaat van R zal 80 mm zijn. Dus de aanbevolen afstand is 40 mm (of minder) , gelijk aan R/2

De communicatie tussen Arduino en de TMP006 is gemaakt met behulp van de SerialSoftware bibliotheek en Adafruit_TMP006.h bibliotheek

#include #include "Adafruit_TMP006.h"/Variabelen voor TMP006-functies************************* ***************/Adafruit_TMP006 tmp006;void setup(){}void loop(){// Lees object IR-temperatuur float objt =tmp006.readObjTempC();// Lees sensortemperatuur ( Externe temperatuur)float dieet =tmp006.readDieTempC();} 

STAP 5 - Externe temperatuur

De waarde van de buitentemperatuur is bepaald met en LM35 sensor (DT pakket).

De LM35-serie is een precisie-geïntegreerd circuit 1-temperatuurapparaat met een uitgangsspanning die lineair evenredig is met de temperatuur van Celsius.

Elke graad Celsius produceert een toename/afname van de spanning van 10 mV

De sensorwaarde is bepaald door de Arduino analoge ingang (AI) te lezen

int TempExtPin =A1; // selecteer de invoerpin float celsius =0, farhenheit =0; // temperatuurvariabelen zweven millivolt; int-sensor;[...]sensor =analogRead (TempExtPin); //Lees LM35-waarde millivolts =(sensor / 1023,0) * 5000; // millivolt output Voltagecelsius =millivolt / 10;  

STAP 6 - Ultrasone positie

Het doel van het gebruik van deze sensor is om de escursie van de vering van de motorfiets te bepalen.

De HC-SR04 het meten van de tijd die de geluidsgolven nodig hebben om terug te keren na het tegenkomen van een obstakel. De uitgezonden bundel van geluidsgolven heeft een conische vorm en hetzelfde geldt voor de gereflecteerde golven van een obstakel.

De snelheid van geluidsgolven in de lucht bij 20°C is ongeveer 343,4 m/s, in dit voorbeeld nemen we voor de eenvoud de geschatte waarde van 340 m/s in overweging .

Gezien de kinematicawet S=V x t (waarbij S:ruimte of verplaatsing van het object, V:snelheid, t:tijd) we kunnen aankondigen dat in ons geval de afstand S=0.034 x T is .

We moeten de tijd per 2 delen omdat de tijd die we hebben omgerekend de tijd is die vroeger door de golven ging en terugkwam, de uiteindelijke formule waarbij t is de tijd die door de sensor wordt geretourneerd in cm/microseconde is:

S=0.034 x t/2

Hieronder ziet u een voorbeeld dat u kunt gebruiken om de afstand van het object te bepalen.

digitalWrite(triggerPort, LOW);// Stuur een puls van 10 microsec naar triggerdigitalWrite(triggerPort, HIGH);delayMicroseconds(10);digitalWrite(triggerPort, LOW);lange duur =pulseIn(echoPort, HIGH);lange r =0,034 * duur / 2; 

De bovenstaande code beschrijft goed hoe de sensor werkt, maar u zult ontdekken dat deze code erg traag en slecht wordt uitgevoerd .

Voor dit project heb ik besloten om de nieuwe bibliotheek genaamd NewPing.h . te proberen Ga voor meer informatie naar deze link en bekijk de volledige Arduino-code van het project.

Gebruik de NewPing.h bibliotheek is heel eenvoudig.

• Voeg de bibliotheek toe

• definieer de trigger- en echo-poort van de HC-SR04

• initialiseert het object

• roep de ReadPositionPing-functie aan.

#include /**************************************** ****** Variabelen definiëren voor HC RS04-functies ************************************ ******/// HC-RS04-poortenint triggerPort =2;int echoPort =3;// NewPing-configuratie van pinnen en maximale afstandNewPing-sonar(triggerPort, echoPort, 200);void setup(){}void loop() {/*** LEES POSITIE ***/int Pos=ReadPositionPing();}int ReadPositionPing(){unsigned int uS =sonar.ping();return sonar.convert_cm(uS);} 

De UWP-software

De software bestaat uit een gebruikersinterface die via bluetooth met de besturingseenheid is verbonden. De gebruikersinterface toont alle gegevens die zijn verzonden vanaf de Arduino en worden verzonden naar IoThub de sensorwaarden.

De seriële communicatie tussen Arduino en de UWP wordt geïnterpreteerd door uit de invoerreeks te lezen.

Elke String ontvangen wordt gevalideerd door te controleren of deze de START . bevat en END markeringen. Als de invoerreeks correct is geformatteerd, zal de toepassing de informatie spugen en weergeven op de gebruikersinterface van de toepassing.

Hieronder ziet u een voorbeeld van een string die door Arduino is verzonden en die de START/END-markeringen bevat, deze string wordt gesplitst door het "pipe"-teken om elke sensorwaarde te bepalen:

$START|40.909409|N|9.520008|E|8|2|2016|15:46:42|0.09|0.000000|0|0|-0.21|0.00|0.00|-0.02|0.98|-|0.00| 35.19|29.58|16|10|$END|

onder de array-definitie na de splitsing van de verzonden string:

• Positie 0 - START-markering

• Positie 1 - Breedtegraad

• Positie 2 - N (Noord)

• Positie 3 - Lengtegraad

• Positie 4 - E (oost)

• Positie 5 - maand

• Positie 6 - dag

• Positie 7 - jaar

• Positie 8 - uu:MM.ss

• Positie 9 - snelheid (km/u)

• Positie 10 - hoogte (m)

• Positie 11 - satellieten (aantal satellieten)

• Positie 12 - hdop (aantal satellieten in gebruik)

• Positie 13 - rollen

• Positie 14 - toonhoogte

• Positie 15 - Xg

• Positie 16 - Yg

• Positie 17 - Zg

• Positie 18 - Audio (Optioneel-momenteel uitschakelen )

• Positie 19 - Afstand (m)

• Positie 20 - Temperatuur (externe temperatuur door LM35)

• Positie 21 - Temperatuur band (bandtemperatuur vanaf TMP006)

• Positie 22 - Schokdemper voor (cm)

• Positie 23 - Achterschokdemper (cm)

• Positie 24 - EINDE-markering

door "Serial Monitor" van de Arduino IDE kunt u zien hoe de Arduino Code werkt:

Om alle gegevens die vanaf de centrale via Bluetooth worden verzonden te beheren, heb ik een Universal Windows Applications ontwikkeld die een mooi voorbeeld is van de kracht van de UWP. Zoals u weet, is een UWP een platform waarmee u de applicatie in alle apparaatfamilies met Windows 10 aan boord kunt uitvoeren.

De gebruikersinterface is heel eenvoudig en intuïtief, aan de linkerkant zie je de Bluetooth-verbindingsfunctie, in het midden 3 meters die worden gebruikt voor het weergeven van de snelheid, hellingshoek en Wheelie-hoek. Alle G-componenten worden weergegeven en aan de rechterkant informatie over de GPS-positie, temperaturen en schokdemperexcursies.

Hoe de app te implementeren in Windows 10 Mobile?

Met Windows 10 SDK Preview Build 10166 introduceerde Microsoft de tool Windows 10 Application Deployment (WinAppDeployCmd.exe).

De Windows 10 Application Deployment (WinAppDeployCmd) is een opdrachtregelhulpprogramma dat kan worden gebruikt om een ​​universele Windows-app te implementeren vanaf een Windows 10-pc naar elk mobiel Windows 10-apparaat. Hiermee kunnen gebruikers een .AppX-bestand implementeren op een apparaat dat is aangesloten via USB of beschikbaar is op hetzelfde subnet zonder toegang tot de volledige Visual Studio-oplossing.

STAP 1:

Zet allereerst uw mobiele apparaat in "Ontwikkelaarsmodus" (ga naar UPDATE &VEILIGHEID => VOOR ONTWIKKELAAR ).

sluit daarna uw apparaat aan via USB en maak het zichtbaar USB-verbinding (er wordt een pincode geretourneerd)

STAP 2:

Klik met de rechtermuisknop op uw Project =>Winkel =>App-pakketten maken

STAP 3:

Selecteer in de wizard App-pakketten maken NEE Als je een lokaal pakket wilt maken en klik op VOLGENDE . Kies daarna processorplatforms om te targeten. Kies voor ons doel het ARM-platform en klik op CREATE .

Aan het einde van het aanmaakproces geeft de wizard ons een lokale URL waar het pakket is gemaakt.

als u de url opent, vindt u het Appx-bestand dat beschikbaar is om op het apparaat te worden geïmplementeerd.

STAP 4:

Open een opdrachtprompt en verplaats uw focus naar C:\Program Files (x86)\Windows Kits\10\bin\x86\

en typ de volgende opdrachtregel

WinAppDeployCmd install -file "C:\work\uwp\Gps\MotorbikeArduino\MotorbikeArduino\AppPackages\V1.35\MotorbikeArduino_1.0.35.0_Debug_Test\MotorbikeArduino_1.0.35.0_arm_Debug.appxbundle" -ip 127.0.0.1 -pin AAA123

(waar AAA123 is de pincode die wordt geretourneerd door uw telefoon die is aangesloten op de USB in associatiemodus)

Aan het einde van het proces wordt de applicatie op uw apparaat geïnstalleerd en kunt u "vastzetten om te starten":

AZURE

Nu zijn we klaar om te beschrijven hoe de Azure-services moeten worden geconfigureerd. Voor dit project zal nodig zijn om te creëren:

• WebApp + SQL Azure

• IoTHUB

• Stream Analytics-VACATURE

• Een DeviceId die wordt gebruikt om gegevens te verzenden naar IoTHUB .

OKE GA! Heeft u een AZURE-account?

• Als NEE, ga dan naar https://azure.microsoft.com/ en maak er een.

• Zo JA... GOED! Ga naar https://portal.azure.com

STAP 1 - IoT Hub maken en configureren:

De IoTHUB is het toegangspunt van de telemetriewaarden naar de Cloud.

Maak uw IoTHub, klik op Nieuw => Internet of Think => IoT Hub en compileer de Hub-velden en klik op Maken

Vervolgens ziet u in uw Azure-dashboard mogelijk de IoT HUB implementeren en na enkele seconden is uw IoT HUB klaar.

Klik op de nieuwe tegel in je dashboard en ga naar Alle instellingen mes.

Zie je IotHub hostnaam en noteer:

In het Beleid voor gedeelde toegang blade, klik op de iothubowner beleid, en kopieer en noteer vervolgens de verbindingsreeks in de iothubowner mes

Ok... je Iot-hub is gemaakt, je bent bijna klaar om hem te gebruiken!

STAP 2 - Streamanalyse maken en configureren

De stream Analytics heeft als doel om alle gegevens die naar de IoTHUB zijn verzonden, te lezen en te schrijven en op te slaan in een databasetabel.

Maak een nieuwe Stream Analytics-taak:

Klik op Nieuw => Internet of Think => Stream Analytics-taak

Vul alle velden in en klik op de knop Aanmaken.

Nu zijn we klaar om Input/Output en de query van de streamAnalityncs JOB te configureren.

Invoer instellen - Selecteer de bron . In ons geval is de bron de IoTHub

Stel de uitvoer in - Selecteer de bestemming. In ons geval is de uitvoer een tabel van de SQL Azure-database (in de volgende stap laat ik je zien hoe je een sql db maakt)

STAP 3 - WebApp + SQL Azure maken

Ga naar dashboard en selecteer WebApp+SQL (Nieuw => Netwerken => Web + mobiel => Web-app + SQL )

Configureer nu uw webapp door de volgende velden samen te stellen:

• App-naam

• Kies een abonnement

• Kies een bronnengroep (als je er geen hebt, maak dan je eerste bronnengroep aan)

• Kies een App Service-abonnement en een prijsniveau (in dit voorbeeld kunt u overwegen een gratis F1-abonnement te kiezen)

Configureer uw SQL, maak een nieuwe en kies de naam , prijsklasse , servernaam en voeg Inloggegevens voor beheerders . toe :

Nu terug naar STAP 2 , zijn we nu klaar om de StreamAnalitycs-query te maken. Klik op de StreamAnalyticJob-tegel en selecteer "Query". Voeg uw zoekopdracht in het rechterpaneel in.

Zoals u kunt zien, beschrijft de query de procesworkflow. Catch the data from "MyTelemetryInputHub" and save them into "SqlAzureMyTelemetry" ... easy&wonderful!!

At the end, we have only to start the JOB clicking the START button.

Create a DeviceId for HUB

This step is necessary in order to create a connection between my device and the IoTHUB. We need to create a new device identity and add into the ID registry of the IoT HUB.

For more information please visit the follow link

To generate a new one deviceId, you have to create a Console Application in Visual Studio.

In the NuGet Package Manager window, search and install the Microsoft.Azure.Devices package.

Add the below code In your Console application, replace your IoTHub Connection String and chose a deviceId alias (in my case the deviced is MyDucatiMonsterDevice ).

class Program{//Install-Package Microsoft.Azure.Devicesstatic RegistryManager registryManager;// Connection String HUBstatic string connectionString ="xxxxxxxxxxxxxx";static void Main(string[] args){registryManager =RegistryManager.CreateFromConnectionString(connectionString);AddDeviceAsync().Wait();Console.ReadLine();}// creates a new device identity with ID myFirstDeviceprivate async static Task AddDeviceAsync(){ string deviceId ="myDucatiMonsterDevice";Device device;try{device =await registryManager.AddDeviceAsync(new Device(deviceId));}catch (DeviceAlreadyExistsException){device =await registryManager.GetDeviceAsync(deviceId);}Console.WriteLine("Generated device key:{0}", device.Authentication.SymmetricKey.PrimaryKey);}} 

Run the console application (press F5) and generate your device key!

WEB application

At this point of the project i thinked about how can i see my telemetry data and how can i show them to my friends and share the results on the social media. to do that I decided to create a responsive web site in ASP .NET

The website consist in a dashboard contains all my telemetries. The data has been read using the Entity framework from SQL Azure.

You can discover the web site by the following url:

Has been created an account for all Hackster Users , SignIn using the following user/psw credentials:

User ID:demoPassword:demo 

The web site is look like this:

And look like this in mobile version:

When you create a web app in azure using the Free tier, the domain name will be something like this:

.azurewebsites.net

To change the domain name you have to buy one and on azure this is very simple! Follow this steps:

• Go to your Azure dashboard and click on you web app Tile.

• Select "Custom domains and SSL " and click on "Buy domains ".

• Fill all fields (about your domain name and your contact informations)

Ducati Monster Wiring

Now is time to Introduce my motorbike, this is my Ducati Monster 695 that for this project has been the cavy.

Below some pictures about my Hardware (control unit) mounted onboard.

to measure the tyre temperature I created a bracket clamped behind the wheel.

One Ultrasonic ranging module HC-SR04 has been fixed under the front headlight. It misures the distance between headlight and front mudguard.

The other one Ultrasonic ranging module has been fixed under the bike seat in order to determined the back shock absorber measuring the distance between seat and rear tyre.

The central unit containing the Arduino, the GPS, the Accelerometer and the external temperature sensor has been fixed behind the seat.

And at the end, after the wiring, my motorbike is look like this

Machine Learning

The last idea of this project has been try to understand if exist a correlation between telemetries data in order to try to understand how to improve my driving style.

My data samples are not relatable because I make different routes every time and the traffic conditions are never the same. I think that a good condition should be use the system in a speedway. I Imagine that in a real race could be usefull to understand by telemetry if you can increase the speed or if you have to decrease the speed according to the output values.

The Machine Learning (ML) embodies the magic of software insights about the data, solves problems by giving information that represents a certain evolution. The ML understands how a given phenomenon will evolve according to the data in its knowledge.

The first approach using the ML is to do Experiments . Using the data, you can play and be able to do the analysis with the aim of investigating the phenomenon that interests us.

Ok let's go to discover the Azure Machine Learning

Go to https://studio.azureml.net and sign in using your Azure account.

On the left of the page click on "Studio"

You will be redirect to your personal Dashboard and now you will be ready to create experiments

• In the experiments blade, Click NEW (on the left button of the page) .

• The first step is to Import data that you would like to use in your ML. In my case I imported the data from SQL Azure.

• Into my Table all data are varchar so i needed to convert it in float and excluding some bad data in order to have only best quality records. Below you can see the query used to import data

select CAST(speed as float) _speed, CAST(roll as float) _roll, CAST(pitch as float) _pitch, CAST(Xg as float) _Xg, CAST(Yg as float) _Yg, CAST(Zg as float) _Zg, CAST(TempExt as float) _TempExt, CAST(TempTyre as float) _TempTyre, CAST(FrontAbsorber as float) _FrontAbsorber, CAST(BackAbsorber as float) _BackAbsorberfrom mytelemetrywhere CAST(speed as float)>3 and CAST(FrontAbsorber as float)>0 and CAST(BackAbsorber as float)>0 and CAST(roll as float)<60 and CAST(roll as float)>-60 

• Then add a SPLIT DATA element in order to use some data to Train your ML and decide the data percentage to use for the configuration.

• A data portion will be used to configure the template and the other portion to see if your model works fine. This will allow me to assess the goodness.

• Add a Train Model and decide what is the field that would you like the model guess and decide which algorithm use for your train.

• Now we verify how he behaved the algorithm giving us a feeling of goodness, to do that we need to use "Score Model ". the SM accept in input 2 sources, the first one is from Train Model and the second one from the SPLIT DATA .

• At the end we ready to estimate the model according to the test data, comparing them with those that have not yet used (Evaluate Model ).

Official Documentation about " Evaluate Model" can be found here

Below there is a sample experiment useful for comparing 2 algorithms using the Evaluation Model , the 2 algorithms are Two-class decision jungle and Two-class decision forest .

When you pass on a scored model for a "two classes" classification algorithm, the evaluation model generates metrics shown below:

Classification Models

The above metrics are reported for evaluating classification models.

(All metrics are reported but the models are ranked by the metric you select for evaluation)

• Accuracy measures the goodness of a classification model as the proportion of true results to total cases. Accuracy =(TP + TN) / (TP + TN + FP + FN)

• Precision is the proportion of true results over all positive results. Precision =TP / (TP + FP)

• Recall is the fraction of all correct results returned by the model. Recall =TP / (TP + TN)

• F-score is computed as the weighted average of precision and recall between 0 and 1, where the ideal F-score value is 1. F1 =2TP / (2TP + FP + FN)

• AUC measures the area under the curve plotted with true positives on the y axis and false positives on the x axis. This metric is useful because it provides a single number that lets you compare models of different types.

As you can see, the Two-class decision forest Algorithm have an Accuracy , Precision ,Recall and F1 Score near the value equal to 1, so i suppose that my model is good described, GREAT !!!

For more details about Evaluate Model please visit the following LINK

Predictive Experiment:

It's time to move our attention on the predictive functionality of the machine learning.

The Training experiment will be convert to a predictive experiment, this feature allows to integrate in others applications the opportunity to use your model and based on your model have a Prediction.

For do that, has been created a new one Experiment, the data source has been the SQL Azure but this time the table used has been a new one. I tried to classify data based on telemetry values.

Now my data look like this and as you can see there is a new column named Scored that represents my classification:

Create the experiment like below, select the Train Model and add a Multiclass algorithm:

• RUN the experiment and see the results:

• Select the Train Model and click on SET UP WEB SERVICE => Predictive Web Service

• Wait some seconds and your predictive service will be ready. Below you can see my Predictive Experiment layout:

• Run this model and then deploy the web service by clicking on the DEPLOY WEB SERVICE button

• Your service will be immediately ready to be used and a dashboard will appear, contain a "TEST" button where you can manually enter data and test your service

• Click TEST button and compile all fields, use some fake values and see the Predictive result:

As you can see the result is equal to "SAFE DRIVING ", this mean that my Predictive service has predicted that my driving style is Safe and no action is needed.

If the Result has been for example "HIGH STRESS HIGH SPEED " that means that I have to reduce speed!

Conclusions about ML:

in this section we understand some things.

• How configure an experiment in ML azure environment

• we found that Two-class decision forest Algorithm well describe my motor bike telemetry and we train the ML for the predictive experiment using the Multiclass decision forest Algorithm

• How to convert our Model in a Web Service creating a predictive experiment

• we found some usefull information about my style of guide. Infact as you can see from the below graphs:

I prefer lean on the right and my lean angle doesn't depend for tyre temperature and from the speed. That mean that my tyres are high quality and in add I undestood that my motorbike prefers Wheelie when the tyre temperature is more than 35°C

Final Conclusions

In this project we covered many technological areas.

We discovered How is possible to create a funny Hardware using an Arduino and some sensor spending less then 60$ and using many services provided by microsoft.

We learned how is easy use Azure and how is interesting use Machine Learning Studio suite.

Has been realized a prototype that certainly needs improvements but i think is a good starting point for future developments from each people enthusiast about C#, Azure, Arduino and MotorBike.

Possible future Developments

To Improve this prototype i think will be usefull implements some things:

• About the mobile app (UWP), in case that no 3G/4G network is available, the data are lost because i'm not able to send the data to azure. Would be usefull develop a buffering logic that in case of "no networking" available, stored the data and send them at a later time.

• Create an APP for mobile platform using Xamarin, would be cool have an app who can run in Android OS and iOS also.

• Use more precise sensors and increase performance/accuracy.

• Make the central unit smaller, maybe using an Arduino MKR1000 .

• Create a social media Webapp to share your motorbike travel and telemetries in order to suggest to biker users what is the dangerous curves and increase the safety.

• Modify the source of the Machine Learning using the Steam Analytics. In my case i prefered use a sql AZURE datasource because it was not possible ride the bike and develop the ML in the same time :)

New branch work flow:

• The new branch consists to sending back to device, through IoTHub , the information about the ML predictive service.

• When the speed value is greater than 100 km/h a new one stream analyticsJob will send the telemetry data to Event Hub.

• A cloud service reads this data from EventHub and send a request to the ML predictive service in order to have a score about the Driving Style .

• The Cloud Service will send back the score to IoTHub , and IoTHub will send it to the device back (Windows Phone in this case)

... and now ENJOY !! :-) feel free to contact me for any questions and tips.

Schema's

circuit diagrams of the Telemetry system. On board scheda MotorbikeProject.fzz