Arduino kontrollerade Servo Exerciser (2 / 2 steg)

Steg 2:

/*************************************************************/
/ *** S W E E P U S E C S--Servo Drive Program V.110308 *** /
/ *** Mark Theobald-- www.DisabledAdventurers.com *** /
/*************************************************************/
#include < Servo.h >
#include < EEPROM.h >

Servo Servo1; Skapa ett Servo objekt
int CPOS = 1500; Nuvarande Position (i uSecs)
int hastighet = 2500; Servo hastighet (1-100 * 300)
int dröjsmål = 1000; Fördröjning mellan sveper (0-5000 uppdateringsförsök)
int INCR = 1; Servo Increment (1-50 uSecs)
int CSTOP = 1; Stanna vid Center (ja eller nej)
int AMIN = 675; Absolut Min (Minimum = 675)
int AMAX = 2325; Absolut Max (maximal = 2325)
int MIN, MAX; Nuvarande MIN & MAX värden
int SPCP; Sopa passerar mittläget
int Ct, LoopCount; Vissa globala variabler
char sträng [80]. En strängbuffert
int antal; Ett antal variabel

int ABYTE, EPAD; för läsa & skriva EEPROM

void StoreDefaults (void);
void RetrieveDefaults (void);
void CheckSerial (void);
void SweepTo (int Position);
void ManualRotation (void);
void ManualEntry (void);
void GetANumber (void);

/*************************************************************/
void setup() {

Servo1.attach (9, AMIN, AMAX). Bifoga SERVO till Pin 9
Servo1.writeMicroseconds (1500); Ståndpunkten Servo till mittläget
Serial.BEGIN (115200); Matcha detta i HyperTerminal!
Serial.Print ("\n\r"); Visa menyn operatör

Serial.print( "-------------------------------------------- \n\r" );
Serial.Print ("S W E E P U S E C S--Servo Drive Program \n\r");
Serial.print( "-------------------------------------------- \n\r" );
Serial.Print ("s/S = hastighet, i/I = flytta mellanskillnad, d/D = fördröjning \n\r");
Serial.Print ("n/N = Min, m/M = Max, < blanksteg > = paus,? = Display \n\r");
Serial.Print ("C = Center stopp, L/R = manuellt läge, X = Återställ \n\r");
Serial.Print ("Z = Store förstahandsval, P = ange position manuellt \n\r");
Serial.print( "-------------------------------------------- " );

MIN = AMIN; Initiera MIN och MAX värden till absolut MIN & MAX värden
MAX = AMAX;
RetrieveDefaults(); Läs alla värden som kan lagras i EEPROM
tag (!. Serial.available()); Vänta på valfri tangent för att börja
Serial.Read(); }

/*************************************************************/
void loop() {

sprintf (sträng, "\n\r%06d:", ++ LoopCount); Hålla reda på loopar
Serial.Print (sträng);
SweepTo (MAX);
Serial.Print ("CW"); Ange sista satsen
CheckSerial();
Delay (fördröjning);

om (CSTOP & & SPCP) {//We vill stanna vid center & &
SweepTo (1500); Sopa passerar mittläget
Serial.Print ("Center");
CheckSerial();
Delay (fördröjning); }

SweepTo (MIN);
Serial.Print ("CCW");
CheckSerial();
Delay (fördröjning);

om (CSTOP & & SPCP) {
SweepTo (1500);
Serial.Print ("Center");
CheckSerial();
Delay (fördröjning); } }

/*************************************************************/
void RetrieveDefaults() {
EPAD = 0;

ABYTE = int (EEPROM.read (EPAD ++));
MIN = ABYTE << 8.
ABYTE = int (EEPROM.read (EPAD ++));
MIN = MIN | ABYTE;
Serial.Print ("\n\rMIN:");
Serial.Print (MIN, DEC);
om (MIN < AMIN || MIN > = MAX) MIN = AMIN;

ABYTE = int (EEPROM.read (EPAD ++));
MAX = ABYTE << 8.
ABYTE = int (EEPROM.read (EPAD ++));
MAX = MAX | ABYTE;
Serial.Print ("MAX:");
Serial.Print (MAX, DEC);
om (MAX < = MIN || MAX > AMAX) MAX = AMAX;

SPCP = MIN < 1500 & & MAX > 1500; Sopa passerar mittläget

ABYTE = int (EEPROM.read (EPAD ++));
HASTIGHET = ABYTE << 8.
ABYTE = int (EEPROM.read (EPAD ++));
HASTIGHET = HASTIGHET | ABYTE;
Serial.Print ("hastighet:");
Serial.Print (hastighet / 100, DEC);
om (hastighet < 100 || SNABBA > 30000) hastighet = 2500;

ABYTE = int (EEPROM.read (EPAD ++));
DELAY = ABYTE << 8.
ABYTE = int (EEPROM.read (EPAD ++));
DELAY = FÖRSENING | ABYTE;
Serial.Print ("försening:");
Serial.Print (försening / 50, DEC);
om (FÖRSENA < 0 || FÖRDRÖJA > 5000) dröjsmål = 1000;

ABYTE = int (EEPROM.read (EPAD ++));
INCR = ABYTE << 8.
ABYTE = int (EEPROM.read (EPAD));
INCR = INCR | ABYTE;
Serial.Print ("INCR:");
Serial.Print (INCR, DEC);
om (INCR < 1 || INCR > 50) INCR = 50; }

/*************************************************************/
void StoreDefaults() {
EPAD = 0;

EEPROM.write (EPAD ++, char ((MIN >> 8) & 0x00FF));
EEPROM.write (EPAD ++, char (MIN & 0x00FF));

EEPROM.write (EPAD ++, char ((MAX >> 8) & 0x00FF));
EEPROM.write (EPAD ++, char (MAX & 0x00FF));

EEPROM.write (EPAD ++, char ((hastighet >> 8) & 0x00FF));
EEPROM.write (EPAD ++, char (hastighet & 0x00FF));

EEPROM.write (EPAD ++, char ((försening >> 8) & 0x00FF));
EEPROM.write (EPAD ++, char (dröjsmål & 0x00FF));

EEPROM.write (EPAD ++, char ((INCR >> 8) & 0x00FF));
EEPROM.write (EPAD, char (INCR & 0x00FF)); }

/*************************************************************/
void CheckSerial() {
char nyckel;

samtidigt (Serial.available()) {
om ((Key = Serial.read()) == 's "|| Nyckel == s ' || Nyckel == "?") {
om (nyckel == 's "& & hastighet > 300) hastighet-= 300;
om (nyckel == s ' & & snabba < 30000) hastighet + = 300;
om (nyckel == "?") Serial.Print ("\n\r");
sprintf (sträng, hastighet: % d", hastighet / 300); 0 - 100
Serial.Print (sträng); }

om (nyckel == "i" || Nyckel == "I" || Nyckel == "?") {
om (nyckel == "i" & & INCR > 1) INCR--;
om (nyckel == "I" & & INCR < 50) INCR ++;
sprintf (sträng, "Incr:% d", INCR); 0 - 50
Serial.Print (sträng); }

om (nyckel == hade "|| Nyckel == hade "|| Nyckel == "?") {
om (nyckel == hade "& & FÖRDRÖJA > 49) försening-= 50;
om (nyckel == hade "& & FÖRDRÖJA < 5000) försening += 50;
sprintf (sträng, försening: % d", dröjsmål / 50); 0 - 100
Serial.Print (sträng); }

om (nyckel == 'n' || Nyckel == 'N' || Nyckel == "?") {
om (nyckel == 'n') om ((MIN-= 20) < AMIN) MIN = AMIN;
om (nyckel == 'N') om ((MIN += 20) > MAX - 1) MIN = MAX - 1.
sprintf (sträng, "Min:% d", MIN);
Serial.Print (sträng);
SPCP = MIN < 1500 & & MAX > 1500; } //Sweep passerar mittläget

om (nyckel == är "|| Nyckel == är "|| Nyckel == "?") {
om (nyckel == är ") om ((MAX-= 20) < MIN + 1) MAX = MIN + 1.
om (nyckel == är ") om ((MAX + = 20) > AMAX) MAX = AMAX;
sprintf (sträng, Max: % d", MAX);
Serial.Print (sträng);
SPCP = MIN < 1500 & & MAX > 1500; }

om (nyckel == "c" || Nyckel == "C") {
CSTOP =! CSTOP;
sprintf (sträng, "\n\rStop @ Center = %s \n\r", CSTOP? "Ja": "Nej");
Serial.Print (sträng); }

om (nyckel == "") {
Serial.Print ("paus");
tag (!. Serial.available()); Pausad - vänta någon nyckel
Serial.Read();
Serial.Print ("Run");}

om (nyckel == "x" || Nyckel == "X") {//Reset alla variabler
HASTIGHET = 7500;
DELAY = 1000;
INCR = CSTOP = SPCP = 1;
MIN = AMIN;
MAX = AMAX; }

om (nyckel == "r" || Nyckel == "R" || Nyckel == "l" || Nyckel == "L")
ManualRotation();

om (nyckel == "z" || Nyckel == "Z") StoreDefaults();

om (nyckel == "p" || Nyckel == "P") {
samtidigt (Serial.available()) Serial.read(); Rensa buffert
ManualEntry(); } } }

/*************************************************************/
void ManualEntry() {
Serial.Print ("\n\n\rMANUAL post läge");
sprintf (sträng, "---MIN:% d, MAX: % d", MIN, MAX);
Serial.Print (sträng);
Serial.Print ("\n\rNumeric Position < ange >, < blanksteg > = Exit \n\r");

samtidigt (1) {
GetANumber();
om (nummer < 0) återvänder;
sprintf (sträng, ": %d", nummer);
Serial.Print (sträng);

om (nummer > = MIN & & nummer < = MAX) {
CPOS = nummer;
Servo1.writeMicroseconds (CPOS);
Serial.Print ("\n\r"); }

annat {
Serial.Print är ("inte i intervallet \n\r");
sprintf (sträng, "%d - %d < Enter > eller < blanksteg > till Exit...\n\r", MIN, MAX);
Serial.Print (sträng); } } }

/*************************************************************/
void GetANumber() {
char nyckel = 0;

Antal = 0;
medan (nyckel! = ' ') {
om (Serial.available()) {
om ((Key = Serial.read()) == 13) återvända; CR
om (nyckel > 47 & & nyckel < 58) {//ASCII '0' t h är du '9'
om (nummer) * = 10; Ingen ledande nollor!
Nummer += (nyckel - 48); } } }

Antal = -1;
hemkomst. }

/*************************************************************/
void ManualRotation() {
char nyckel;

Serial.Print ("\n\n\rMANUAL ROTATION läge");
Serial.Print ("\n\rl/L=Left, r/R = höger, < blanksteg > = Exit \n\r");

samtidigt (1) {
om (Serial.available()) {
om ((Key = Serial.peek()) == "p" || Nyckel == "P") återvända;

om ((Key = Serial.read()) == "") {
Serial.Print ("\n\r");
hemkomst. }

om (nyckel == "r" || Nyckel == "R" || Nyckel == "l" || Nyckel == "L") {
om (nyckel == "r" & & CPOS < AMAX) CPOS ++;

om (nyckel == "R") {
om (CPOS < AMAX - 9) + CPOS = 10;
annat CPOS = AMAX; }

om (nyckel == "l" & & CPOS > AMIN) CPOS--;

om (nyckel == "L") {
om (CPOS > AMIN + 9) CPOS-= 10.
annat CPOS = AMIN; }

Servo1.writeMicroseconds (CPOS);
sprintf (sträng, ": %d", CPOS);
Serial.Print (sträng); } } } }

/*************************************************************/
void SweepTo (int Position) {

om (CPOS < Position) medan ((CPOS += INCR) < = Position) {
Servo1.writeMicroseconds (CPOS);
för (Ct = hastighet; CT < 30000; CT++); }

annat samtidigt ((CPOS-= INCR) > = Position) {
Servo1.writeMicroseconds (CPOS);
för (Ct = hastighet; CT < 30000; CT++); }

om (CPOS! = Position) Servo1.writeMicroseconds (CPOS = Position); }

/*************************************************************/
/ *** SLUTET PROGRAM *** /
/*************************************************************/