Stap 8: Auto bereik instelling
Er is ook een mooi blok dat soepele servo versnelling en vertraging gebaseerd op de cosinus-functie genereert. Gotta min trig.
Geniet van!
/ * > Auto_Set_Range <
Het testen van code voor servo met gehackte feedback van interne pot.
Servo control kabel aangesloten op de digitale 10 en 11
Positie Feedback kabel aangesloten op analoge 0 en 1
Servo's zijn declaired in matrixvorm voor eenvoudige toevoeging van meer servo's.
Een spanning divider voortbouwen ARef pin: + 5V--4.7K--Aref--3.3K--GND
Met een gereguleerde spanning van 4.78V zal hij als gevolg van analoge referentie ~1.85V zijn
(Zie http://arduino.cc/en/Reference/AnalogReference)
Dit zal het verhogen van de resolutie van de potentiometer lezen.
Gebruik de volgende opdrachten op de Toggle tussen het lezen van de servo-feedback
en het lezen van elke andere analoge pin die moet zien 5V als referentie
analogReference(EXTERNAL); analoge 1023 ingesteld voltage dat op de ARef pin
analogReference(DEFAULT); Hiermee stelt u analoge 1023 op 5V of 3.3V afhankelijk van voeding
DEZE CODE KOMT IN OP 8,9 K IN HET GEHEUGEN. ZONDER ALLE SERIËLE FEEDBACK IS 8.3K
HET KON WORDEN VERMINDERD DOOR IEMAND SLIMMER DAN IK, IK BEN ZEKER STAAN!
*/
#include < Servo.h > //import servo bibliotheek
#include < EEPROM.h > //import EEPROM bibliotheek
Const int numServos = 2; Hoeveel servo's heb je?
Const int sPin [numServos] = {10,11}; welke pinnen ze correleren aan?
Servo servo [numServos]; verklaren van de servo-array
int highPulse [numServos]; hoge pulsbreedte
int lowPulse [numServos]; lage pulsbreedte
int een [numServos]; lowPulse feedback lezing
int B [numServos]; highPulse feedback lezing
int hier [numServos]; verplaatsen van hoek
int er [numServos]; hoek naar
float x [numServos]; hoek geconverteerd naar radialen voor het afleiden van de cosinus Golf
int h;
int t;
int feedBack; gebruikt om servo feedback waarde te houden
int knop = 2;
int e = 1; EEPROM adres om te beginnen met servo gegevens opslaan/ophalen
int hoek; hoek, is afgeleid van cosinus functie. verzonden naar servo in lus
int btwReadings = 20; vertragingstijd tussen
int whlReading = 3; vertragingstijd tussen analoge lezingen van interne pot
Boole rangeTest = false;
Booleaanse doneMove [numServos];
VOID Setup {}
Serial.begin(19200); uitgang voor seriële initialiseren
Serial.println ("het is op!");
analogReference(EXTERNAL);
pinMode (knop, INPUT);
for (int i = 0; ik < numServos; i ++) {}
pinMode (sPin[i],OUTPUT);
}
int n = EEPROM.read(0);
Als (n == 20) {}
callRange();
}
Als (rangeTest == false) {}
for (int i = 0; ik < numServos; i ++) {}
setRange(i); Ga test het bereik en de waarden instellen
doneMove [i] = true;
}
rangeTest = true;
EEPROM.write(0,20); geven aan de toekomstige startups dat we hebben dit gedaan!
}
delay(1000);
}
void loop {}
for (int i = 0; ik < numServos; i ++) {}
Als (doneMove [i] == true) {}
doneMove [i] = false;
hier [i] = er [i];
er [i] = willekeurige (180,1) + 0,5;
Als (daar [i] == here[i]) {daar [i] = willekeurige (180,1) + 0,5;}
Als (hier [i] < there[i]) {x [i] = 0;} else {x [i] = 180;}
Serial.Print ("Move servo");
Serial.Print(i);
Serial.Print ("uit");
Serial.Print(here[i]);
Serial.Print ("to");
Serial.println(there[i]);
}
}
calcCos (huidige en gewenste beeldpositie, stap, servo matrixpositie)
for (int i = 0; ik < numServos; i ++) {}
hoek = calcCos(here[i],there[i],1.5,i);
Als (doneMove [i] == false) {}
Servo[i].write(Angle);
delay(5);
}
}
} / / VOID LOOP END
/*
DEZE FUNCTIE AUTO-SETS HET SERVO-BEREIK
WORDT UITGEGAAN VAN DE DRUKKNOP OP PIN 2
*/
ongeldig setRange(int x) {//parameter doorgegeven is matrixpositie servo
int pb = 0; gebruikt om te houden van de drukknop lezing
int test; algemeen gebruik variabele
int h;
int t;
int pulse = 1500; eerst die ons pulse gebruikt in bereik test
Serial.Print ("druk op de knop instellen bereik van Servo[");
Serial.Print(x);
Serial.println("].");
while(!PB) {}
PB = digitalRead(Button);
}
PB = 0;
Serial.Print ("bereik limieten instellen in... 3");
voor (int i = 2; ik > = 0; i--) {//count beneden drie seconden
delay(1000);
Serial.Print("..");
Serial.Print(i);
}
Serial.println();
Servo[x].attach(sPin[x]);
vertraging(20);
Servo[x].writeMicroseconds(Pulse); Stuur servo naar midden van bereik
delay(2000); wachten om er te komen
{}
Pulse += 10; incriment ons pulse breedte
readMove(x,pulse);
} while(h > t); voorwaarde voor het bereik blijven testen
highPulse [x] = puls-20; wegblijven van extreme bereik
B [x] = h-10; feedback uit de buurt van extreme aanpassen
Serial.println();
Servo[x].writeMicroseconds(highPulse[x]);
Pulse = highPulse [x];
delay(500);
{}
Pulse-=10;
readMove(x,pulse);
} while(h < t);
lowPulse [x] = puls + 20;
Een [x] = t + 10;
Servo[x].writeMicroseconds(lowPulse[x]);
feedBack = getFeedback(x); huidige lezen uit de pot nemen
Er is [x] = map(feedBack,A[x],B[x],0,180); feedback naar mate uitvoer aanpassen
Servo[x].attach(sPin[x],lowPulse[x],highPulse[x]); deze servo koppelen
Servo[x].write(there[x]); afgeven van pulse voor waar we zijn
doneMove [x] = true;
test een [x] = >> 8;
writeE(test); lage feedbackscore lezing opslaan
writeE(A[x]);
testen = B [x] >> 8;
writeE(test); opslaan van hoge terugkoppeling lezing
writeE(B[x]);
testen = lowPulse [x] >> 8;
writeE(test); opslaan van lage control-pulse
writeE(lowPulse[x]);
testen = highPulse [x] >> 8;
writeE(test); hoge pols slaan
writeE(highPulse[x]);
Serial.println ("Feedback-bereik:");
Serial.Print(A[x]);
Serial.Print ("<>");
Serial.println(B[x]);
Serial.println ("ons Pulse bereik:");
Serial.Print(lowPulse[x]);
Serial.Print ("<>");
Serial.println(highPulse[x]);
Serial.Print("servo[");
Serial.Print(x);
Serial.println ("] aangesloten, gegevens die worden opgeslagen in EEPROM");
} //end setRange()
VOID writeE (byte b) {}
EEPROM.write(e,b);
e += 1;
}
VOID readMove (int n, int p) {}
t = getFeedback(n);
Servo[n].writeMicroseconds(p);
delay(btwReadings);
h = getFeedback(n);
Serial.println(h);
} //END SET BEREIK
/*
DEZE FUNCTIE LEEST DE INTERNE SERVO POTENTIOMETER
*/
int getFeedback(int a) {}
int j;
int de gemiddelde;
int resultaat;
int test;
int lezen [20];
Boolean gedaan;
voor (j = 0; j < 20; j ++) {}
lezen van [j] = analogRead(a); ruwe gegevens ophalen uit servo potentiometer
delay(whlReading);
} / / Sorteer de laag naar hoog in array van lezingen
= false; duidelijke vlag sorteren
terwijl (gedaan! = true) {/ / eenvoudige swap sorteren, worden de getallen van de laagste tot hoogste gesorteerd
= true;
voor (j = 0; j < 20; j ++) {}
Als ([j] lezen > lezen [j + 1]) {/ / hier nummers sorteren
testen = lezen [j + 1];
lezen van [j + 1] = lezen van [j];
lezen van [j] = test;
= false;
}
}
}
betekenen = 0;
voor (int k = 6; k < 14; k ++) {//discard de hoogste 6 en 6 laagste lezingen
bedoel += lezen [k];
}
resultaat = gemiddelde/8; gemiddelde nuttige lezingen
Return(result);
} / / END GET FEEDBACK
/*
DEZE FUNCTIE ROEPT EERDER BEREIK INSTELLEN VANAF EEPROM
WORDT UITGEGAAN VAN DE DRUKKNOP OP PIN 2
*/
ongeldig callRange() {}
int test;
Serial.Print ("To reset opgeslagen bereik druk op pin 2");
for (int i = 5; ik > = 0; i--) {}
Serial.Print("..");
Serial.Print(i);
for (int j = 0; j < 100; j ++) {}
Als (digitalRead(Button) == 1) {}
Serial.println();
delay(1000);
terugkeer;
}
delay(10);
}
}
Serial.println();
Serial.println ("Retreiving servo gegevens");
for (int i = 0; ik < numServos; i ++) {}
testen = readE();
Een [i] = test << 8; opgeslagen lage feedbackscore lezing krijgen
Een [i] = A [i] + readE();
testen = readE();
B [i] = test << 8; opgeslagen hoge terugkoppeling lezing krijgen
B [i] = B [i] + readE();
testen = readE();
lowPulse [i] = test << 8; krijgen storeed lage controle pulse
lowPulse [i] = lowPulse [i] + readE();
testen = readE();
highPulse [i] = test << 8; krijgen opgeslagen hoge controle-pulse
highPulse [i] = highPulse [i] + readE();
feedBack = getFeedback(i); huidige lezen uit de pot nemen
er [i] = map(feedBack,A[i],B[i],0,180); feedback naar mate uitvoer aanpassen
Servo[i].attach(sPin[i],lowPulse[i],highPulse[i]); deze servo koppelen
Servo[i].write(there[i]); afgeven van pulse voor waar we zijn
doneMove [i] = true; instellen om eerst verplaatsen
Serial.println ("Feedback-bereik:");
Serial.Print(A[i]);
Serial.Print ("<>");
Serial.println(B[i]);
Serial.println ("ons Pulse bereik:");
Serial.Print(lowPulse[i]);
Serial.Print ("<>");
Serial.println(highPulse[i]);
Serial.Print("servo[");
Serial.Print(i);
Serial.println ("] aangesloten, gegevens opgehaald vanaf EEPROM");
Serial.Print ("servo");
Serial.Print(i);
Serial.Print ("huidige positie =");
Serial.println(there[i]);
Serial.println();
}
rangeTest = true; Stel de vlag rangeTest
} //end callRange()
byte readE() {}
byte E = EEPROM.read(e);
e += 1;
terugkeer E;
} //END OPROEP BEREIK
/*
DEZE FUNCTIE MAAKT SMOOTH (COSINUS) BEWEGING VAN HIER NAAR DAAR
*/
int calcCos (int h, int th, float s, int n) {}
int r;
int;
if(h < th) {}
x [n] += s;
Als (x [n] > = 181) {doneMove [n] = true;}
r = (cos(radians(x[n]))*100);
een = map(r,100,-100,h,t);
}
if(h > th) {}
x [n]-= s;
Als (x [n] < = -1) {doneMove [n] = true;}
r = (cos(radians(x[n]))*100);
een = map(r,-100,100,h,t);
}
terug een;
} //END CALC COS
