Ski kompis: Pälsen som lär dig att åka skidor. (4 / 6 steg)

Steg 4: Koden

Du är antingen två typer av människor:

1. kodare som faktiskt vill förstå koden.

2. människor som inte vet en slicka av kodning och bara vill rå källfilen.

Goda nyheter för dig, denna sida täcker båda!

Observera att denna kod är under GPL v3 licens.

Så för er som bara vill rå källfilen, är det på Github:

** Men innan du klickar på den länken, Vänligen scrolla ner och Läs den koden settings.* *

Hela filen

För dig som vill förstå koden, tack för uppskattar den tid skriva det! Låt oss hoppa rätt i:

Vi måste först inkludera dessa tre bibliotek. Förvirrad vad de sista två är? Det är okej. De dök upp i tidigare sömnad tutorial som jag länkade. Om du redan vet hur du lägger till bibliotek för Arduino IDE, men är här den direkta länken till Github förråd:

Adafruit Sensor bibliotek

Adafruit LSM303 bibliotek

#include < Wire.h >
#include < Adafruit_Sensor.h >
#include < Adafruit_LSM303.h >

Nästa jag ska gå över de funktioner som jag använder i koden:

Flash blinkar båda LED tillsammans.

alternativa växlar både LED.

Blink blinkar båda LED när.

/**
* Flash lysdioder med vissa mellanrum.
*/
{Ogiltig flash (int millisekunder)
digitalWrite(9,HIGH);
digitalWrite(12,HIGH);
Delay(Milliseconds);
digitalWrite(9,LOW);
digitalWrite(12,LOW);
Delay(Milliseconds);
digitalWrite(9,HIGH);
digitalWrite(12,HIGH);
Delay(Milliseconds);
digitalWrite(9,LOW);
digitalWrite(12,LOW);
Delay(Milliseconds);
}

/**
* Alternativa lysdioder för en viss tid.
*/
Ogiltigt alternativ (int millisekunder) {
digitalWrite(9,HIGH);
digitalWrite(12,LOW);
Delay(Milliseconds);
digitalWrite(9,LOW);
digitalWrite(12,HIGH);
Delay(Milliseconds);
digitalWrite(12,LOW);
}
/**
* Blinka Lysdioderna för en viss tid.
*/
{Ogiltig blink (int millisekunder)
digitalWrite(9,HIGH);
digitalWrite(12,HIGH);
Delay(Milliseconds);
digitalWrite(9,LOW);
digitalWrite(12,LOW);
}

toDegrees omvandlar ett par x och y magnetiska behandlingen till en rubrik i grader.

/**
* Konverterar ett par LSM303 magnetiska avläsningar i grader.
*/
int toDegrees (double x, dubbel y) {
dubbel deg = (atan2(y,x) * 180) /PI;
tillbaka (int) deg;
}

procent tar två nummer och skapar en procent med först som 100% och andra som fraktionen.

/**
* Tar två nummer och skapar en procent.
*/
int procent (dubbel hela, dubbel fract) {
dubbla ret = fract/(whole/100);
avkastning (int) ret;
}

*** Kod inställningar ***

turnTime är den tid som du uppskatta det skulle ta användaren aktivera i millisekunder. Exempelvis kan du minska turnTime för att hjälpa lära länkade vänder vs. förlängning tur tiden att lämna utrymme för förklaringar om ski form mellan varv.

nedgången är i huvudsak hur mycket du vill att användaren ska sakta ner i slutet av varje varv. Exempelvis förutsätter anger till 2 att användaren kommer att halvera sin hastighet före roterande. Om du undervisar användaren gå in en gradvis pizza, kanske du vill minska värdet till låt oss säga 1.3 så att användaren har att minska deras hastighet av 1/4 innan svarvning.

maxLearnCount är ett antal varv som använder enheten att lära sig kursen innan du börjar att tala om för användaren om att åka skidor med lysdioder. Detta är användbart om en kulle har kanter med olika längder och du vill få den genomsnittliga tid det tar för att korsa de olika längderna.

skiPercent är den procentandel tid som du vill att enheten ska vänta med att tala om för användaren att sakta ner. Exempelvis kan vrida procentuella ner för mer gradvisa svängar, medan motsatsen vanligen mer abrupt vänder.

readyTime är den allmänna tid du tror krävs för att få på och av liften i millisekunder.

=== INSTÄLLNINGAR FÖR ===

Hur lång tid det tar för att vända i millisekunder.
Ändra för länkande svängar, tid för förklaringar däremellan vänder...
int turnTime = 1500;

Den acceleration/nedgången bestämmer hur mycket vi vill att användaren ska
sakta ner innan svarvning.
Ändra för långsam stoppa (pizza), snabbt stoppa (hockey stopp)
dubbel nedgång = 2;

Hur många varv vi vill att koden till lär dig för.
Ändra för större noggrannhet om kullen har något off side längder, etc.
int maxLearnCount = 4;

Procentandelen av tiden det tar för att korsa berget innan koden
begings talar om för användaren att sakta ner genom lysdioder.
Ändra för gradvisa stoppa vs. instant stopp.
int skiPercent = 75.

Hur lång tid det tar för att få på och av antingen lift eller "magic carpet" i millisekunder
int readyTime = 5000;

=== INSTÄLLNINGAR FÖR ===

Nu låt oss initiera accelerometern:

Initiera LSM303 accelerometern.
Adafruit_LSM303 lsm;

Nästa vi kommer att gå igenom åtkomstkoden. Det finns två delar.

1. initiera Lamporna på jackan.

void setup() {//Set två LED portar till utgångarna.
pinMode(9,OUTPUT);
pinMode(12,OUTPUT);
Flash dem för att visa de arbetar.
Flash(100);

2. Ladda accelerometern. Om det misslyckas, bara alternativa lysdioder att visa fel.

Börja ladda LSM303...
Om det inte laddas, flash upprepade gånger...
om (! lsm.begin()) {
While(true) {
Flash(300);
}
}
Slut installationen.
}

Nu för de olika variablerna.

learnCount används för att hålla reda på hur många varv enheten har tillbringat lärande, stoppa en gång den når det maximala beloppet för lärande blir uppsättningen ovan.

lastTurn används för att komma ihåg sista gången en sväng inträffade, att tillåta mätning av tiden för en sväng.

lastDir används för att hålla användaren allmänna övergripande inriktning.

lastAcc används för att hålla allmänna övergripande accelerationen av användaren.

dir är en matris som innehåller de två föreslagna riktningarna av varje varv.

dirTime är den genomsnittliga tid det tar för användaren att korset leden.

currentDir används för att hålla reda på vilken riktning som användaren ska gå i.

liftMode används för att spara batteri när du går upp en lift eller "magic carpet."

Används för att starta att få betydelse för leden.
int learnCount = 0; Används för att bestämma längden på varv.
lång lastTurn; //Used att upptäcka varv och för att lära sig jaga.
int lastDir = -1; Används för att också upptäcka varv och för att lära sig jaga.
int lastAcc = -1; De två riktningarna av kursen.
int dir [2]. Tid det tar för att korsa spåret.
int dirTime = -1; Strömmens riktning kursen går.
int currentDir = 0; Lyft läge sparar batteriet genom att endast regelbundet kontrollera uppåtgående rörelse.
booleska liftMode = false;

Slutligen loop() koden. Det finns flera delar:

1. Läs/genomsnittligt data från accelerometern.

Koden tar fem avläsningar och i genomsnitt dem för bättre noggrannhet.

Det finns 3 viktiga variabler här:

magAvg är den riktning som användaren står inför i grader. Detta används för att vägleda användaren.

accAvg är den övergripande x och y accelerationen av användaren. Detta används för att upptäcka när användaren saktar ner.

liftAvg är den övergripande z accelerationen av användaren. Detta används för att upptäcka "lyfta" motion (uppåt)

void loop() {//To få exakt noggrannhet, ta 5 avläsningar och genomsnittlig dem.
int magRead [5].
Det bör noteras att accRead matrisen tar i X och Y avläsningar
från accelerometern för allmänna hastighet. Matrisen liftRead
tar i Z avläsningar att upptäcka om någon är antingen på en hiss
eller att få på/av. Förhoppningsvis klarnar upp förvirring!
int accRead [5].
int liftRead [5].
för (int jag = 0; jag < 5; i ++) {
LSM.Read();
Konvertera magnet data till grader...
magRead [i] = toDegrees(lsm.magData.x,lsm.magData.y);
accRead [i] = abs ((lsm.accelData.x + lsm.accelData.y)/2);
liftRead [i] = lsm.accelData.z;
}
Nu genomsnittliga avläsningarna...
int magAvg = 0;
int accAvg = 0;
int liftAvg = 0;
för (int jag = 0; jag < 5; i ++) {
magAvg = magAvg + magRead [i];
accAvg = accAvg + accRead [i];
liftAvg = liftAvg + liftRead [i];
}
magAvg = magAvg/5;
accAvg = accAvg/5;
liftAvg = liftAvg/5;

2. Kontrollera om användaren skidåkning ner för berget, har överstigit beloppet av maximal inlärning vänd (maxLearnCount) som ovan och är skidåkning slalom.

IF(!liftMode) {
om (learnCount > = maxLearnCount) {
om (liftAvg < 0) {

3. att veta vad vi ovan, kontrollera först för att se om användaren har avslutat en sväng baserat på hur lång tid det tog dem över berget i inlärningsprocessen, därav variabeln dirTime . Överföra till andra turn och dröjsmål baserat på hur länge vi att tiden mellan varv är, därav variabeln turnTime .

länge nu = millis();
långa dif = nu - lastTurn;
IF(percent(dirTime,DIF) > = 100) {
lastTurn = nu;
currentDir = 1-currentDir;
Ge dem tid för att vända...
Blink(turnTime);

4. om vi inte har nått den roterande fasen ännu, kolla om vi ska tala om för användaren att sakta efter en viss tid baserat på när användaren ska börja stoppa, därför som variabeln skiPercent ovan. Om inte, måste vi vägleda användaren bör de i vilken riktning att gå. Eftersom ingen är perfekt, ska vi ge dem 10 grader slack på vardera sidan.

} annat if(percent(dirTime,dif) < = skiPercent) {
om (magAvg > = dir [currentDir] + 10) {
Gå till vänster
digitalWrite(12,HIGH);
digitalWrite(9,LOW);
} else om (magAvg < = dir [currentDir] - 10) {
Gå till höger
digitalWrite(9,HIGH);
digitalWrite(12,LOW);
} annat {
Bo
digitalWrite(12,LOW);
digitalWrite(9,LOW);
}

5. det enda alternativet vänster är om vad som händer att vi har nått tid att tala om för användaren att sakta ner. Vi gör detta genom att växla lampor fram och tillbaka tills användaren har nått den roterande fasen.

} annat {//SLOW ner...
Alternate(300);
}

6. denna else -sats är för om användaren är going downhill, vilket innebär att användaren måste gå uppförsbacke vid denna punkt, så vi kommer att sätta användaren i lift läge så att vi kan spara batteri och sedan skjuta så att användaren har tid att komma upp på lift/magiska mattan.

} annat {//Go till lift läge för nästa slinga.
liftMode = sant;
Delay(readyTime);
}

7. detta annat uttalande är för om användaren är förbi lära-läge, vilket innebär att användaren måste vara i inlärningsläge på denna punkt. Detta är viktigt eftersom om användaren tar sitt första lärande tur, vi vill inte röra till variabeln dirTime , eftersom uppenbarligen deras första trek över leden tar längre tid eftersom de har att få fart. Med det kolla vi först för att se till att detta är inte är den 1: a inspelning av data, eftersom det skulle innebära att vi inte skulle ha tidigare data att bygga på. Nästa vi i genomsnitt ut riktningen av användaren med deras senaste riktning så att vi kan få en noggrann avläsning till där vi vill användaren att gå efter inlärningsläge för detta viss tur.

} annat {//Time att lära sig!
Se till att detta är inte första gången inspelning data.
om (lastDir! = -1 & & lastAcc! = -1 & & dirTime! = -1) {
lastDir = (magAvg + lastDir) / 2;

8. för att upptäcka svängar, vänta vi tills användaren börjar utgjuta av hastigheten till den grad att vi vill ha dem till, därav den avmattning variabla som ovan. Vi kommer att koppla den riktning som användaren har pågått 1 av de 2 föreslagna riktningarna vill vi användaren att gå i. (vi har en föreslagen riktning för går vänster över hela berget och en annan för att gå rätt över). Vi måste också att registrera hur lång tid det tog att korsa berget och skriver att till variabeln dirTime .

Kontrollera om de sakta ner av hur snabbt vi vill att de ska sakta ner.
om (accAvg < = (lastAcc/nedgång)) {
dir [currentDir] = lastDir;
learnCount + = 1;
currentDir = 1 - currentDir;
Spela in hur lång tid det tog för att korsa berget...
länge nu = millis();
Genomsnitt då med hur lång tid det tog sista sväng.
dirTime = (dirTime + (nu - lastTurn)) / 2;
lastTurn = nu;
Ge dem en andra vända...
Delay(turnTime);
}
lastAcc = (accAvg + lastAcc) / 2;

9. detta annat uttalande är för om detta är den första inspelningen av data, vilket innebär att det är, så vi bara tilldela aktuella data till deras respektive variabler så att på nästa loop kan vi börja i genomsnitt ut uppgifterna.

} annat {//Make inspelningar för första sväng.
lastDir = magAvg;
lastAcc = accAvg;
lastTurn = millis();
}

10. detta annat uttalande är för om användaren är i hissen läge, vilket innebär att de är. För att spara batteriet, när vi bara på nedåtgående rörelse endast en gång per sekund och flash LED's för att ange att användaren vi är fortfarande i lift läge.

{}} annat {
om (liftAvg < 0) {
liftMode = false;
Delay(readyTime);
}
Blink(100);
Delay(950);
}

11. genom att fördröja 50 millisekunder, vi inte överbelasta koden och spara batteri, eftersom även genom att kontrollera mätvärden varje 50 millisekunder, det motsvarar läsa data 20 gånger per sekund.

Delay(50);}