Arduino controlado Servo ejercitador (2 / 2 paso)

Paso 2:

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

Servo1 servo;                   Crea un objeto Servo
int CPOS = 1500;        Posición actual (uSecs)
int velocidad = 2500;        Servo de velocidad (1-100 * 300)
int retardo = 1000;        Retardo entre barre (0-5000 milisegundos)
int INCR = 1;              Incremento de servo (1-50 uSecs)
int CSTOP = 1;              Pare en el centro (sí o No)
int AMIN = 675;          Absoluto mínimo (mínimo = 675)
int AMAX = 2325;        Máximo absoluto (máximo = 2325)
int MIN, MAX;                    Corriente MIN & MAX valores
int SPCP;                         Posición de barrido pases centro
int Ct, LoopCount;          Algunas Variables globales
char cadena [80];               Un búfer de cadena
int número;                     Una número Variable

int ABYTE, EPAD;           para la lectura y escritura de EEPROM

void StoreDefaults (void);
void RetrieveDefaults (void);
void CheckSerial (void);
void SweepTo (int posición);
void ManualRotation (void);
void ManualEntry (void);
void GetANumber (void);

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

Servo1.Attach (9, AMIN, AMAX);            Conecte el SERVO al Pin 9
Servo1.writeMicroseconds (1500);     Servo de posición a posición central
Serial.Begin (115200);                          Esto coincide en HyperTerminal.
Serial.Print ("\n\r");                                  Mostrar el menú operador

Serial.print( "-------------------------------------------- \n\r" );
Serial.Print ("S W E E P U S E C S--Servo Drive programa \n\r");
Serial.print( "-------------------------------------------- \n\r" );
Serial.Print ("s/S = velocidad, i/I = incremento de movimiento, d/D = demora \n\r");
Serial.Print ("n/N = Min, m/M = Max, < espacio > = pausa,? = pantalla \n\r");
Serial.Print ("C = centro parada, L/R = modo Manual, X = Reset \n\r");
Serial.Print ("Z = tienda por defecto, P = introducir posición manualmente \n\r");
Serial.print( "-------------------------------------------- " );

MIN = AMIN;                    Inicializar el MIN y MAX valores absoluto MIN & MAX valores
MAX = AMAX;
RetrieveDefaults();        Leer todos los valores almacenados en la EEPROM
mientras (!. Serial.Available());                Esperar a que cualquier tecla para comenzar
Serial.Read();   }

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

sprintf (cadena, "\n\r%06d:", ++ LoopCount);    Seguimiento de los bucles
Serial.Print (cadena);
SweepTo (MAX);
Serial.Print ("CW");                  Indicar último movimiento
CheckSerial();
retraso (retardo);

Si (CSTOP & & SPCP) {//We quiere parar en el centro & &
SweepTo (1500);                     Barra pasa a posición central
Serial.Print ("centro");
CheckSerial();
retraso (retardo);    }

SweepTo (MIN);
Serial.Print ("CCW");
CheckSerial();
retraso (retardo);

Si (CSTOP & & SPCP) {}
SweepTo (1500);
Serial.Print ("centro");
CheckSerial();
retraso (retardo);    }    }

/*************************************************************/
void RetrieveDefaults() {}
APAD = 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 ||  MINUTO > = MAX) MIN = AMIN;

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

SPCP = MIN < 1500 & & MAX > 1500;     Posición de barrido pases centro

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

ABYTE = int (EEPROM.read (EPAD ++));
RETARDO = ABYTE << 8;
ABYTE = int (EEPROM.read (EPAD ++));
RETARDO = RETRASO | ABYTE;
Serial.Print ("DELAY:");
Serial.Print (retraso / 50, DEC);
Si (retrasar < 0 ||  RETRASO > 5000) retardo = 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() {}
APAD = 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 ((velocidad >> 8) & 0x00FF));
EEPROM.write (EPAD ++, char (velocidad & 0x00FF));

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

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

/*************************************************************/
void CheckSerial() {}
char clave;

mientras (Serial.available()) {}
Si ((clave = Serial.read()) == de ' ||  Clave == de ' ||  Clave == '?')    {
Si (clave == de ' & & velocidad > 300) velocidad-= 300;
Si (clave == de ' & & < 30000 la velocidad) velocidad += 300;
Si (clave == '?')  Serial.Print ("\n\r");
sprintf (cadena, "velocidad: % d", velocidad / 300);     0 - 100
Serial.Print (cadena);    }

Si (clave == 'i' ||  Clave == 'I' ||  Clave == '?')    {
Si (clave == 'i' & & INCR > 1) INCR--;
Si (clave == 'I' & & INCR < 50) INCR ++;
sprintf (cadena, "Incr:% d", INCR);            0 - 50
Serial.Print (cadena);    }

Si (clave == había ' ||  Clave == había ' ||  Clave == '?')    {
Si (clave == había ' & & retraso > 49) demora-= 50;
Si (clave == había ' & & retrasar < 5000) demora += 50;
sprintf (cadena, "retraso: % d", retardo / 50);     0 - 100
Serial.Print (cadena);    }

Si (clave == ' n ' ||  Clave == ' n ' ||  Clave == '?')    {
Si (clave == n) si ((MIN-= 20) < AMIN) MIN = AMIN;
Si (clave == n) si ((MIN += 20) > MAX - 1) MIN = MAX - 1;
sprintf (cadena, "Min:% d", MIN);
Serial.Print (cadena);
SPCP = MIN < 1500 & & MAX > 1500;    } //Sweep pases centro posición

Si (clave == soy ' ||  Clave == soy ' || Clave == '?')    {
Si (clave == estoy ') si ((máximo-= 20) < MIN + 1) MAX = MIN + 1;
Si (clave == estoy ') si ((MAX += 20) > AMAX) MAX = AMAX;
sprintf (cadena, "Max: % d", MAX);
Serial.Print (cadena);
SPCP = MIN < 1500 & & MAX > 1500;    }

Si (clave == 'c' ||  Clave == 'C') {}
CSTOP =! CSTOP;
¿sprintf (cadena, "\n\rStop @ centro = %s \n\r", CSTOP? "Sí": "No");
Serial.Print (cadena);    }

Si (clave == ' ') {}
Serial.Print ("Pause");
mientras (!. Serial.Available());      Hizo una pausa - espera para cualquier tecla
Serial.Read();
Serial.Print ("ejecutar");    }

Si (clave == 'x' ||  Clave == 'X') {//Reset todas las variables
VELOCIDAD = 7500;
RETARDO = 1000;
INCR = CSTOP = SPCP = 1;
MIN = AMIN;
MAX = AMAX;    }

Si (clave == 'r' ||  Clave == 'R' ||  Clave == 'l' ||  Clave == 'L')
ManualRotation();

Si (clave == 'z' ||  Clave == 'Z') StoreDefaults();

Si (clave == 'p' ||  Clave == 'P') {}
mientras que Serial.read() (Serial.available());       Borrar búfer
ManualEntry();    }    }    }

/*************************************************************/
void ManualEntry() {}
Serial.Print ("\n\n\rMANUAL modo de ingreso");
sprintf (cadena, "---MIN:% d, MAX: % d", MIN, MAX);
Serial.Print (cadena);
Serial.Print ("posición de \n\rNumeric entrar en < >, < espacio > = salida \n\r");

mientras que {} (1)
GetANumber();
Si vuelve (número < 0);
sprintf (cadena, ": %d", número);
Serial.Print (cadena);

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

Else {}
Serial.Print ("no es en la gama \n\r");
sprintf (cadena, "%d - %d < Enter > o < espacio > a Exit...\n\r", MIN, MAX);
Serial.Print (cadena);    }    }    }

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

Número = 0;
mientras que (tecla! = ' ') {}
Si (Serial.available()) {}
Si ((clave = Serial.read()) == 13) volver;     CR
Si (clave > 47 & & tecla < 58) {//ASCII '0' t h es '9'
Si (número) * = 10;                    Sin los ceros!
Número += (tecla - 48);    }    }    }

Número = -1;
retorno;    }

/*************************************************************/
void ManualRotation() {}
char clave;

Serial.Print ("\n\n\rMANUAL modo de rotación");
Serial.Print ("\n\rl/L=Left, r/R = derecha, espacio de < > = salida \n\r");

mientras que {} (1)
Si (Serial.available()) {}
Si ((clave = Serial.peek()) == 'p' ||  Clave == 'P') volver;

Si ((clave = Serial.read()) == ' ') {}
Serial.Print ("\n\r");
retorno;    }

Si (clave == 'r' ||  Clave == 'R' ||  Clave == 'l' ||  Clave == 'L') {}
Si (clave == 'r' & & CPOS < AMAX) CPOS ++;

Si (clave == 'R') {}
Si (CPOS < AMAX - 9) CPOS += 10;
otro CPOS = AMAX;    }

Si (clave == 'l' & & CPOS > AMIN) CPOS--;

Si (clave == 'L') {}
Si (CPOS > AMIN + 9) CPOS-= 10;
otro CPOS = AMIN;    }

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

/*************************************************************/
void SweepTo (int posición) {}

Si (CPOS < posición) mientras que ((CPOS += INCR) < = posición) {}
Servo1.writeMicroseconds (CPOS);
para la (Ct = velocidad; CT < 30000; CT++);    }

otra cosa mientras que ((CPOS = INCR) > = posición) {}
Servo1.writeMicroseconds (CPOS);
para la (Ct = velocidad; CT < 30000; CT++);    }

Si (CPOS! = posición) Servo1.writeMicroseconds (CPOS = posición);    }

/*************************************************************/
/ *** FIN PROGRAMA *** /
/*************************************************************/