Arduino contrôlée Servo exerciseur (2 / 2 étapes)

Étape 2 :

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

Servo Servo1 ;                   Créer un objet de Servo
int CPOS = 1500 ;        Position actuelle (en uSecs)
int vitesse = 2500 ;        Vitesse du servo (1-100 * 300)
int DELAY = 1000 ;        Délai entre les balayages (0-5000 millisecondes)
int INCR = 1 ;              Incrément de servo (uSecs 1-50)
int CSTOP = 1 ;              S’arrêter au Centre (oui ou non)
int AMIN = 675 ;          Absolu Min (Minimum = 675)
int AMAX = 2325 ;        Maximum absolu (Maximum = 2325)
int MIN, MAX ;                    Courant MIN & MAX valeurs
int PCPTS ;                         Position centrale de Passes de balayage
int Ct, LoopCount ;          Quelques Variables globales
char String [80] ;               Un tampon de chaîne
int nombre ;                     Une nombre Variable

int ABYTE, EPAD ;           pour la lecture et l’écriture 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) ;            Fixer le SERVO jusqu'à la broche 9
Servo1.writeMicroseconds (1500) ;     Position des Servo à Position centrale
Serial.Begin (115 200 bauds) ;                          Cela correspond dans HyperTerminal !
Serial.Print ("\n\r") ;                                  Afficher le Menu de l’opérateur

Serial.print( "-------------------------------------------- \n\r" );
Serial.Print (« S W E E P U S E C S--servovariateur programme \n\r ") ;
Serial.print( "-------------------------------------------- \n\r" );
Serial.Print ("s/S = vitesse, i/I = mouvement d’augmentation d’échelon, d/D = retard \n\r") ;
Serial.Print (« n/N = Min, m/M = Max, < espace > = Pause,? = affichage \n\r ") ;
Serial.Print ("C = Centre Stop, L/R = Mode manuel, X = Reset \n\r") ;
Serial.Print ("Z = Store Defaults, P = entrez manuellement les Postion \n\r") ;
Serial.print( "-------------------------------------------- " );

MIN = AMIN ;                    Initialiser le MIN et MAX valeurs absolue min & MAX valeurs
MAX = AMAX ;
RetrieveDefaults() ;        Lire toutes les valeurs pouvant avoir été stockées en EEPROM
while (!. Serial.available()) ;                Attendre pour n’importe quelle touche pour commencer
Serial.Read() ;   }

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

sprintf (String, "\n\r%06d:", ++ LoopCount) ;    Garder une trace des boucles
Serial.Print (String) ;
SweepTo (MAX) ;
Serial.Print ("CW") ;                  Indiquer le dernier mouvement
CheckSerial() ;
Delay (retard) ;

Si (CSTOP & & CCPP) {//We veut pas s’arrêter au centre & &
SweepTo (1500) ;                     Balayage passe position centrale
Serial.Print ("Centre") ;
CheckSerial() ;
Delay (retard) ;    }

SweepTo (MIN) ;
Serial.Print (« Convention ») ;
CheckSerial() ;
Delay (retard) ;

Si (CSTOP & & CCPP) {}
SweepTo (1500) ;
Serial.Print ("Centre") ;
CheckSerial() ;
Delay (retard) ;    }    }

/*************************************************************/
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) ;
Si (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) ;
Si (MAX < = MIN || MAX > AMAX) MAX = AMAX ;

CCPP = MIN 1500 < & & MAX > 1500 ;     Position centrale de Passes de balayage

ABYTE = int (EEPROM.read (EPAD ++)) ;
Vitesse = ABYTE << 8 ;
ABYTE = int (EEPROM.read (EPAD ++)) ;
VITESSE = VITESSE | ABYTE ;
Serial.Print ("vitesse:") ;
Serial.Print (vitesse / 100, DEC) ;
Si (vitesse < 100 ||  VITESSE > 30000) Vitesse = 2500 ;

ABYTE = int (EEPROM.read (EPAD ++)) ;
RETARD = ABYTE << 8 ;
ABYTE = int (EEPROM.read (EPAD ++)) ;
RETARD = RETARD | ABYTE ;
Serial.Print ("retard:") ;
Serial.Print (DELAY / 50, DEC) ;
Si (retarder < 0 ||  RETARD > 5000) DELAY = 1000 ;

ABYTE = int (EEPROM.read (EPAD ++)) ;
INCR = ABYTE << 8 ;
ABYTE = int (EEPROM.read (EPAD)) ;
INCR = INCR | ABYTE ;
Serial.Print (« INCR: ") ;
Serial.Print (INCR, DEC) ;
Si (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 ((vitesse >> 8) & 0x00FF)) ;
EEPROM.write (EPAD ++, char (vitesse & 0x00FF)) ;

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

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

/*************************************************************/
void CheckSerial() {}
char clé ;

alors que {(Serial.available())
Si ((clé = Serial.read()) == de ' ||  Clé == les de ' ||  Clé == '?')    {
Si (clé == de ' & & vitesse > 300) Vitesse-= 300 ;
Si (clé == s ' & & vitesse < 30000) Vitesse += 300 ;
Si (clé == '?')  Serial.Print ("\n\r") ;
sprintf (chaîne, « vitesse: % d », vitesse / 300) ;     0 - 100
Serial.Print (String) ;    }

Si (clé == « i » ||  Touche « I » == ||  Clé == '?')    {
Si (clé == « i » & & INCR > 1) INCR--;
Si (clé == « I » & & INCR < 50) INCR ++ ;
sprintf (chaîne, "Incr:% d", INCR) ;            0 - 50
Serial.Print (String) ;    }

Si (clé == a ' ||  Clé == a ' ||  Clé == '?')    {
Si (clé == a ' & & retarder > 49) DELAY-= 50 ;
Si (clé == a ' & & retarder < 5000) retard += 50 ;
sprintf (chaîne, « retard: % d », retard / 50) ;     0 - 100
Serial.Print (String) ;    }

Si (clé == n ||  Clé == n ||  Clé == '?')    {
Si (clé == ' ne) si ((MIN-= 20) < AMIN) MIN = AMIN ;
Si (clé == ' ne) si ((MIN += 20) > MAX - 1) MIN = MAX - 1 ;
sprintf (chaîne, "Min:% d", MIN) ;
Serial.Print (String) ;
CCPP = MIN 1500 < & & MAX > 1500 ;    } //Sweep passes neutre

Si (clé == suis ' ||  Clé == suis ' || Clé == '?')    {
Si (clé == suis ') si ((MAX-= 20) < MIN + 1) MAX = MIN + 1 ;
Si (clé == suis ') si ((MAX += 20) > AMAX) MAX = AMAX ;
sprintf (chaîne, « Max: % d », MAX) ;
Serial.Print (String) ;
CCPP = MIN 1500 < & & MAX > 1500 ;    }

Si (clé == « c » ||  Clé == "C") {}
CSTOP = ! CSTOP ;
sprintf (String, "\n\rStop @ Centre = %s \n\r", CSTOP ? "Oui": "Non") ;
Serial.Print (String) ;    }

Si (clé == "") {}
Serial.Print ("Pause") ;
while (!. Serial.available()) ;      Pause - attendre pour n’importe quelle touche
Serial.Read() ;
Serial.Print ("Run") ;    }

Si (clé == « x » ||  Clé == 'X') {//Reset toutes les variables
VITESSE = 7500 ;
RETARD = 1000 ;
INCR = CSTOP = PCPTS = 1 ;
MIN = AMIN ;
MAX = AMAX ;    }

Si (clé == « r » ||  Clé == « R » ||  Clé == « l » ||  Clé == "L")
ManualRotation() ;

Si (clé == « z » ||  Clé == 'Z') StoreDefaults() ;

Si (clé == « p » ||  Clé == 'P') {}
tout en Serial.read() (Serial.available()) ;       Tampon Clear
ManualEntry() ;    }    }    }

/*************************************************************/
void ManualEntry() {}
Serial.Print ("MODE d’entrée \n\n\rMANUAL") ;
sprintf (String, "---MIN:% d, MAX: % d", MIN, MAX) ;
Serial.Print (String) ;
Serial.Print ("Position \n\rNumeric < entrez >, < espace > = sortie \n\r") ;

tandis que (1) {}
GetANumber() ;
Si (numéro < 0) return ;
sprintf (String, ": %d", numéro) ;
Serial.Print (String) ;

Si (nombre > = MIN & & numéro < = MAX) {}
CPOS = nombre ;
Servo1.writeMicroseconds (CPOS) ;
Serial.Print ("\n\r") ;    }

else {}
Serial.Print ("n’est pas dans la gamme \n\r") ;
sprintf (String, "%d - %d < Enter > ou < espace > à Exit...\n\r", MIN, MAX) ;
Serial.Print (String) ;    }    }    }

/*************************************************************/
void GetANumber() {}
char de Key = 0 ;

Nombre = 0 ;
tandis que (touche! = "") {}
Si {(Serial.available())
Si ((clé = Serial.read()) == 13) return ;     CR
Si (clés > 47 & & clés < 58) {//ASCII « 0 » t h vous êtes « 9 »
Si nombre (Number) * = 10 ;                    Aucune attaque ne zéros !
Numéro += (Key - 48) ;    }    }    }

Nombre = -1 ;
retour ;    }

/*************************************************************/
void ManualRotation() {}
char clé ;

Serial.Print ("MODE de ROTATION de \n\n\rMANUAL") ;
Serial.Print (« \n\rl/L=Left, r/R = droite, < espace > = sortie \n\r ") ;

tandis que (1) {}
Si {(Serial.available())
Si ((clé = Serial.peek()) == « p » ||  Clé == 'P') return ;

Si ((clé = Serial.read()) == "") {}
Serial.Print ("\n\r") ;
retour ;    }

Si (clé == « r » ||  Clé == « R » ||  Clé == « l » ||  Clé == "L") {}
Si (clé == « r » & & CPOS < AMAX) CPOS ++ ;

Si (clé == « R ») {}
Si (CPOS < AMAX - 9) CPOS += 10 ;
d’autre CPOS = AMAX ;    }

Si (clé == « l » & & CPOS > AMIN) CPOS--;

Si (clé == « L ») {}
Si (CPOS > AMIN + 9) CPOS-= 10 ;
d’autre CPOS = AMIN ;    }

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

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

Si (CPOS < Position) tandis que ((CPOS += INCR) < = Position) {}
Servo1.writeMicroseconds (CPOS) ;
pour (Ct = Vitesse ; CT < 30000 ; CT++) ;    }

autre chose tout en ((CPOS = INCR) > = Position) {}
Servo1.writeMicroseconds (CPOS) ;
pour (Ct = Vitesse ; CT < 30000 ; CT++) ;    }

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

/*************************************************************/
/ *** FIN PROGRAMME *** /
/*************************************************************/