Stap 2:
Deze code is uitgebreid getest en ik ben niet bewust van eventuele bugs!
/*************************************************************/
/ *** S W E E P U S E C S--Servo Drive programma V.110308 *** /
/ *** Mark Theobald-- www.DisabledAdventurers.com *** /
/*************************************************************/
#include < Servo.h >
#include < EEPROM.h >
Servo Servo1; Een Servo-Object maken
int CPOS = 1500; Huidige positie (in usec)
int SPEED = 2500; Servo snelheid (1-100 * 300)
int vertraging = 1000; Vertraging tussen veegt (0-5000 msec.)
int INCR = 1; Servo Increment (1-50 usec)
int CSTOP = 1; Halte centrum (ja of Nee)
int AMIN = 675; Absolute Min (Minimum = 675)
int AMAX = 2325; Absolute Max (maximale 2325 =)
int MIN, MAX; Huidige MIN en MAX waarden
int SPCP; Sweep Passes middenpositie
int Ct, LoopCount; Enkele globale variabelen
char String [80]; Een tekenreeksbuffer
int getal; Een aantal variabele
int ABYTE, EPAD; voor lezen & schrijven EEPROM
VOID StoreDefaults (void);
VOID RetrieveDefaults (void);
VOID CheckSerial (void);
VOID SweepTo (int positie);
VOID ManualRotation (void);
VOID ManualEntry (void);
VOID GetANumber (void);
/*************************************************************/
VOID Setup {}
Servo1.attach (9, AMIN, AMAX); De SERVO koppelen aan Pin 9
Servo1.writeMicroseconds (1500); Positie Servo naar Midden
Serial.begin (115200); Dit in HyperTerminal overeenkomen!
Serial.Print ("\n\r"); Toon het Menu van de Operator
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 = snelheid, i/I = verhuizing Increment, d/D = vertraging \n\r");
Serial.Print ("n/N = Min, m/M = Max, < spatie > = pauze,? = Display \n\r");
Serial.Print ("C = Center Stop, L/R = handmatige modus, X = Reset \n\r");
Serial.Print ("Z = winkel Defaults, P = positie handmatig invoeren \n\r");
Serial.print( "-------------------------------------------- " );
MIN = AMIN; MIN en MAX-waarden naar ABSOLUTE MIN en MAX waarden initialiseren
MAX = AMAX;
RetrieveDefaults(); Lees alle waarden die zijn opgeslagen in EEPROM
terwijl (!. Serial.available()); Wachten op een willekeurige toets om te beginnen
Serial.Read(); }
/*************************************************************/
void loop {}
sprintf (String, "\n\r%06d:", ++ LoopCount); Bijhouden van Loops
Serial.Print (String);
SweepTo (MAX);
Serial.Print ("CW"); Laatste deel geven
CheckSerial();
vertraging (DELAY);
Als (CSTOP & & SPCP) {//We wilt stoppen bij center & &
SweepTo (1500); Vegen passeert middenpositie
Serial.Print ("Midden");
CheckSerial();
vertraging (DELAY); }
SweepTo (MIN);
Serial.Print ("Linksom");
CheckSerial();
vertraging (DELAY);
Als (CSTOP & & SPCP) {}
SweepTo (1500);
Serial.Print ("Midden");
CheckSerial();
vertraging (DELAY); } }
/*************************************************************/
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);
Als (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);
Als (MAX < = MIN || MAX > AMAX) MAX = AMAX;
SPCP = MIN < 1500 & & MAX > 1500; Sweep Passes middenpositie
ABYTE = int (EEPROM.read (EPAD ++));
SNELHEID = ABYTE << 8;
ABYTE = int (EEPROM.read (EPAD ++));
SNELHEID = SNELHEID | ABYTE;
Serial.Print ("snelheid:");
Serial.Print (snelheid / 100, DEC);
Als (< 100 snelheid || SNELHEID > 30000) snelheid = 2500;
ABYTE = int (EEPROM.read (EPAD ++));
VERTRAGING = ABYTE << 8;
ABYTE = int (EEPROM.read (EPAD ++));
VERTRAGING = VERTRAGING | ABYTE;
Serial.Print ("vertraging:");
Serial.Print (vertraging / 50, DEC);
Als (vertraging < 0 || > 5000 VERTRAGEN) vertraging = 1000;
ABYTE = int (EEPROM.read (EPAD ++));
INCR = ABYTE << 8;
ABYTE = int (EEPROM.read (EPAD));
INCR = INCR | ABYTE;
Serial.Print ("INCR:");
Serial.Print (INCR, DEC);
Als (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 ((snelheid >> 8) & 0x00FF));
EEPROM.write (EPAD ++, char (snelheid & 0x00FF));
EEPROM.write (EPAD ++, char ((vertraging >> 8) & 0x00FF));
EEPROM.write (EPAD ++, char (vertraging & 0x00FF));
EEPROM.write (EPAD ++, char ((INCR >> 8) & 0x00FF));
EEPROM.write (EPAD, char (INCR & 0x00FF)); }
/*************************************************************/
VOID CheckSerial() {}
char sleutel;
terwijl (Serial.available()) {}
Als ((sleutel = Serial.read()) == de ' || Sleutel == de ' || Belangrijkste == '?') {
Als (sleutel == van ' & & snelheid > 300) snelheid-= 300;
Als (sleutel == de ' & & snelheid < 30000) snelheid += 300;
Als (sleutel == '?') Serial.Print ("\n\r");
sprintf (String, "snelheid: % d", snelheid / 300); 0 - 100
Serial.Print (String); }
Als (sleutel 'i' == || Sleutel 'I' == || Belangrijkste == '?') {
Als (sleutel == "i" & & INCR > 1) INCR--;
Als (sleutel == "I" & & INCR < 50) INCR ++;
sprintf (String, Incr:%'d ' vanaf, INCR); 0 - 50
Serial.Print (String); }
Als (sleutel == had' || Sleutel == had' || Belangrijkste == '?') {
Als (sleutel == had' & & vertraging > 49) vertraging-= 50;
Als (sleutel == had' & & vertraging < 5000) vertraging += 50;
sprintf (String, "vertraging: % d", vertraging / 50); 0 - 100
Serial.Print (String); }
Als (sleutel == 'n' || Sleutel == 'N' || Belangrijkste == '?') {
Als (sleutel == 'n') als ((MIN-= 20) < AMIN) MIN = AMIN;
Als (sleutel == 'N') als ((MIN += 20) > MAX - 1) MIN = MAX - 1;
sprintf (String, Min:%'d ' vanaf, MIN);
Serial.Print (String);
SPCP = MIN < 1500 & & MAX > 1500; } //Sweep passes middenpositie
Als (sleutel == ben ' || Sleutel == ben ' || Belangrijkste == '?') {
Als (sleutel == ben ') als ((MAX-= 20) < MIN + 1) MAX = MIN + 1;
Als (sleutel == ben ') als ((MAX += 20) > AMAX) MAX = AMAX;
sprintf (String, "Max: % d", MAX);
Serial.Print (String);
SPCP = MIN < 1500 & & MAX > 1500; }
Als (toets 'c' == || Belangrijkste == 'C') {}
CSTOP =! CSTOP;
sprintf (String, "\n\rStop @ het centrum = %s \n\r", CSTOP? "Ja": "No");
Serial.Print (String); }
Als (sleutel == ' ') {}
Serial.Print ("Pause");
terwijl (!. Serial.available()); Onderbroken - wachten op een willekeurige toets
Serial.Read();
Serial.Print ("Run"); }
Als (sleutel == 'x' || Belangrijkste == 'X') {//Reset alle variabelen
SNELHEID = 7500;
VERTRAGING = 1000;
INCR = CSTOP = SPCP = 1;
MIN = AMIN;
MAX = AMAX; }
Als (toets 'r' == || Toets 'R' == || Toets 'l' == || Belangrijkste == 'L')
ManualRotation();
Als (sleutel == 'z' || Belangrijkste == 'Z') StoreDefaults();
Als (sleutel == 'p' || Belangrijkste == 'P') {}
terwijl Serial.read() (Serial.available()); Buffer leeg
ManualEntry(); } } }
/*************************************************************/
VOID ManualEntry() {}
Serial.Print ("\n\n\rMANUAL modus");
sprintf (String, "---MIN:% d, MAX: % d", MIN, MAX);
Serial.Print (String);
Serial.Print ("\n\rNumeric positie < invoeren >, < spatie > = Exit \n\r");
terwijl (1) {}
GetANumber();
Als (aantal < 0) keren;
sprintf (String, ": %d", nummer);
Serial.Print (String);
Als (nummer > = MIN & & nummer < = MAX) {}
Onderverdeling = nummer;
Servo1.writeMicroseconds (onderverdeling);
Serial.Print ("\n\r"); }
else {}
Serial.Print Is ("niet In bereik \n\r");
sprintf (String, "%d - %d < Enter > of < spatie > naar Exit...\n\r", MIN, MAX);
Serial.Print (String); } } }
/*************************************************************/
VOID GetANumber() {}
Sleutel char = 0;
Aantal = 0;
terwijl (sleutel! = "") {}
Als (Serial.available()) {}
Als ((sleutel = Serial.read()) 13 ==) terugkeer; CR
Als (Key > 47 & & Key < 58) {//ASCII '0' t h bent u '9'
Als (Number) nummer * = 10; Geen Leading nullen!
Nummer += (Key - 48); } } }
Aantal = -1;
terugkeer; }
/*************************************************************/
VOID ManualRotation() {}
char sleutel;
Serial.Print ("\n\n\rMANUAL rotatie modus");
Serial.Print ("\n\rl/L=Left, r/R = rechts, < spatie > = Exit \n\r");
terwijl (1) {}
Als (Serial.available()) {}
Als ((sleutel = Serial.peek()) == 'p' || Belangrijke 'P' ==) terugkeer;
Als ((sleutel = Serial.read()) == ' ') {}
Serial.Print ("\n\r");
terugkeer; }
Als (toets 'r' == || Toets 'R' == || Toets 'l' == || Belangrijkste == 'L') {}
Als (toets 'r' == & & CPOS < AMAX) CPOS ++;
Als (toets 'R' ==) {}
Als (CPOS < AMAX - 9) CPOS += 10;
anders CPOS = AMAX; }
Als (toets 'l' == & & CPOS > AMIN) CPOS--;
Als (sleutel == 'L') {}
Als (CPOS > AMIN + 9) CPOS-= 10;
anders CPOS = AMIN; }
Servo1.writeMicroseconds (onderverdeling);
sprintf (String, ": %d", CPOS);
Serial.Print (String); } } } }
/*************************************************************/
VOID SweepTo (int positie) {}
Als (CPOS < positie) terwijl ((CPOS += INCR) < = positie) {}
Servo1.writeMicroseconds (onderverdeling);
voor (Ct = snelheid; CT < 30000; CT++); }
anders terwijl ((CPOS-= INCR) > = positie) {}
Servo1.writeMicroseconds (onderverdeling);
voor (Ct = snelheid; CT < 30000; CT++); }
Als (CPOS! = positie) Servo1.writeMicroseconds (CPOS = positie); }
/*************************************************************/
/ *** EINDE PROGRAMMA *** /
/*************************************************************/