Paso 7: El código de Arduino (sin modificar)
/*Robot conducido servo comandada por entrada en serie
Busca un conjunto de caracteres ASCII en la señal a enviar
comandos a un conjunto de servos para manejar un pequeño robot. Pin LED #13
permanecerá encendida durante el movimiento del servo y blink para cambios de velocidad.
El circuito de mínimo:
* LED conectado desde el pin 13 de tierra (o utilizar LED incorporado en la mayoría de Arduino)
* Servos con los cables de señal conexión a los pines 3 y 5 (alimentación de 5v y tierra para
servos pueden también conectarse a Arduino, o la energía puede provenir de fuente externa)
* Entrada serial conectado al pin RX 0
* Salida serie conectado al pin TX 1
Circuitos adicionales (opcionales):
* Avanzar hacia telémetro ultrasónico en el pin digital 7
* Hacia abajo frente a telémetro ultrasónico en el pin digital 8
Nota: Si todavía no tienes un dispositivo serie para conectar con, usted puede utilizar el
construido en el Monitor Serial en el software de Arduino cuando conecto via USB para probar.
También, asegúrese de que a los pines RX y TX disconect de otros dispositivos cuando se trata de programar
el Arduino USB.
creado 2010
por Tim Heath Ryan Hickman y Glen Arrowsmith
Visite http://www.cellbots.com para obtener más información
*/
#include < Servo.h >
#include < EEPROM.h >
#define BUFFERSIZE 20
#define EEPROM_servoCenterLeft 1
#define EEPROM_servoCenterRight 2
#define EEPROM_speedMultiplier 3
#define EEPROM_servosForcedActive 4
#define EEPROM_lastNeckValue 5
#define DEFAULT_servoCenterLeft 90
#define DEFAULT_servoCenterRight 90
#define DEFAULT_speedMultiplier 5
#define DEFAULT_servosForcedActive falso
#define DEFAULT_servosForcedActive falso
#define DEFAULT_lastNeckValue 255
** CONFIGURACIÓN GENERAL **-configuración de preferencias generales
DEPURACIÓN boolean = false; Si salida de depuración en serie es en defauly (puede ser movido de un tirón con el comando 'h')
const int ledPin = 13; LED se enciende durante la ejecución de servos
char * driveType = "servo"; Utilizar el "motor" cuando los robots tiene un controlador de motor DC o el "servo" para accionar las ruedas de servos
** CONFIGURACIÓN SERVO **-valores Configurable basan en pines utilizados y servo dirección
const int servoPinLeft = 9;
const int servoPinRight = 10;
const int servoPinHead = 12; Servo que controla el ángulo del teléfono
const int servoDirectionLeft = 1; Utilizar 1 o -1 para el retroceso
const int servoDirectionRight = -1; Utilizar 1 o -1 para el retroceso
int servoCenterLeft = DEFAULT_servoCenterLeft; Ajuste de PWM para ningún movimiento en el servo izquierdo
int servoCenterRight = DEFAULT_servoCenterLeft; Ajuste de PWM para ningún movimiento en el servo derecho
int servoPowerRange = 30; Gama PWM de centro que servos responden mejor establecer (a 30 para trabajar en el rango de 60-120 centro de 90)
const maxRunTime largo = 2000; Tiempo máximo de funcionamiento para servos sin mando adicional. * Debe utilizar un comando para definir esto. *
int speedMultiplier = DEFAULT_speedMultiplier; Ajuste de la velocidad por defecto. Utiliza un rango de 1-10
int lastNeckValue = DEFAULT_lastNeckValue;
** CONFIGURACIÓN del controlador de MOTOR ** - para uso con los tableros como el conductor del motor de Pololu (también utiliza izquierda/derecha configuración de servo pin arriba)
int leftMotorPin_1 = 9;
int leftMotorPin_2 = 8;
int rightMotorPin_1 = 10;
int rightMotorPin_2 = 11;
int motor_stby = 12;
** GAMA encontrar ***-los ajustes siguientes son para Telémetros ultrasónicos. OK para lave como-es si no tiene en su robot
larga dist, microsegundos, cm, pulgadas; Utilizado por el telémetro para calcular distancias
const int rangePinForward = 7; Pin digital de telémetro hacia adelante (para distancia de objeto frente bot)
const int rangeToObjectMargin = 0; Gama en cm al objeto hacia adelante (bot parará cuando la distancia está más cerca de este - conjunto a 0 si no hay ningún sensor)
const int rangePinForwardGround = 8; Pin digital de telémetro frente hacia abajo en la parte delantera (para límite de detección de mesa)
const int rangeToGroundMargin = 0; Gama en cm para la tabla (bot se detendrá cuando la distancia es superior a este valor 0 si no hay ningún sensor)
const int rangeSampleCount = 3; Número de lecturas de la gama media de un valor más estable y
Crear objetos de servo para controlar los servos
Servo myservoLeft;
Servo myservoRight;
Servo myservoHead;
Ninguna configuración requerida para estos parámetros
Boolean servosActive = false; asumir los servos no se mueve cuando empezamos
Boolean servosForcedActive = DEFAULT_servosForcedActive; sólo se detendrá cuando considerados peligrosos
stopTime=millis() largo sin firmar; utilizado para calcular el tiempo de ejecución para servos
char incomingByte; Entrada serie valores
char mensaje [8]; Para pasar mensajes nuevo serial
inBytes Char [BUFFERSIZE]; Buffer para la serie de mensajes
int serialIndex = 0;
int serialAvail = 0;
void setup() {}
pinMode (servoPinLeft, salida);
pinMode (servoPinRight, salida);
pinMode (servoPinHead, salida);
pinMode(leftMotorPin_1,OUTPUT);
pinMode(leftMotorPin_2,OUTPUT);
pinMode(rightMotorPin_1,OUTPUT);
pinMode(rightMotorPin_2,OUTPUT);
pinMode (ledPin, salida);
digitalWrite(servoPinLeft,0);
digitalWrite(servoPinRight,0);
digitalWrite(servoPinHead,0);
digitalWrite(motor_stby,HIGH);
Serial.Begin(115200);
servoCenterLeft = readSetting (EEPROM_servoCenterLeft, servoCenterLeft);
servoCenterRight = readSetting (EEPROM_servoCenterRight, servoCenterRight);
speedMultiplier = readSetting (EEPROM_speedMultiplier, speedMultiplier);
servosForcedActive = readSetting (EEPROM_servosForcedActive, servosForcedActive);
lastNeckValue = readSetting (EEPROM_lastNeckValue, lastNeckValue);
Si (lastNeckValue! = DEFAULT_lastNeckValue) {}
myservoHead.attach(servoPinHead);
myservoHead.write(lastNeckValue);
}
}
Con seguridad Lee EEPROM
int readSetting (int memoryLocation, int ValorPredeterminado (DefaultValue)) {}
int valor = EEPROM.read(memoryLocation);
Si (valor == 255) {}
EEPROM.write (memoryLocation, defaultValue);
}
devolver valor;
}
Establece la configuración de EEPROM para los valores por defecto
void setEepromsToDefault() {}
servosForcedActive = DEFAULT_servosForcedActive;
speedMultiplier = DEFAULT_speedMultiplier;
servoCenterRight = DEFAULT_servoCenterRight;
servoCenterLeft = DEFAULT_servoCenterLeft;
lastNeckValue = DEFAULT_lastNeckValue;
EEPROM.write (EEPROM_servosForcedActive, DEFAULT_servosForcedActive);
EEPROM.write (EEPROM_speedMultiplier, DEFAULT_speedMultiplier);
EEPROM.write (EEPROM_servoCenterRight, DEFAULT_servoCenterRight);
EEPROM.write (EEPROM_servoCenterLeft, DEFAULT_servoCenterLeft);
EEPROM.write (EEPROM_lastNeckValue, DEFAULT_lastNeckValue);
Si {} (depuración)
Serial.println ("EEPROM todos valores a valores por defecto.");
}
}
Comandos de texto direccional ("hacia adelantados" / "hacia atrás") a convertir velocidad servo calculado
int directionValue (char * directionCommand, int servoDirection) {}
Si (directionCommand == "forward") {}
volver (10 * speedMultiplier * servoDirection);
}
else if (directionCommand == "hacia atrás") {}
volver (-10 * speedMultiplier * servoDirection);
}
Else {}
Si (depuración) {Serial.println ("Houston, tenemos un problema!");}
return 0; Intento para establecer valor a centro - esto no debería ser necesario
}
}
Comandos de texto se traducen en valores PWM para el bot mover (izquierda servo comando, comando servo derecho)
moveBot largo sin signo (commandLeft char *, char * commandRight) {}
int valueLeft = directionValue (commandLeft, servoDirectionLeft) + servoCenterLeft;
int valueRight = directionValue (commandRight, servoDirectionRight) + servoCenterRight;
driveWheels (valueLeft, valueRight);
}
Motores de servo Drive o CD para mover el robot con valores en el rango -100 a 100 para izquierda y derecha
driveWheels largo sin signo (int valueLeft, int valueRight) {}
Separar ambos pernos de servo que dejarán de gemir y desenergizar los motores para que no maten las lecturas de la brújula
Si (valueLeft == 0 y valueRight == 0) {}
myservoLeft.detach();
myservoRight.detach();
}
Conducir las ruedas basadas en driveType "servo"
Si (driveType == "servo") {}
valueLeft = valueLeft * servoDirectionLeft; Tirón de positivo a negativo si es necesario basado en servo dirección valor ajuste
valueRight = valueRight * servoDirectionRight;
Asignar valores "w" a la gama estrecha que los servos respondan a
valueLeft = mapa (valueLeft, -100, 100, (servoCenterLeft - servoPowerRange), (servoCenterLeft + servoPowerRange));
valueRight = mapa (valueRight, -100, 100, (servoCenterRight - servoPowerRange), (servoCenterRight + servoPowerRange));
digitalWrite (ledPin, HIGH); prende el LED
Reiniciar los servos PWM y enviar comandos
myservoLeft.attach(servoPinLeft);
myservoRight.attach(servoPinRight);
myservoLeft.write(valueLeft);
myservoRight.write(valueRight);
Escupa algunos información de diagnóstico sobre la serie
Si {} (depuración)
Serial.Print ("movimiento izquierda servo");
Serial.Print (valueLeft, DEC);
Serial.Print ("y derecha");
Serial.println (valueRight, DEC);
}
}
Conducir las ruedas basadas en el "motor" driveType
Else {}
Ajustar pernos de motor izquierdos para girar en la dirección deseada
Si (valueLeft < 0) {}
digitalWrite(leftMotorPin_1,LOW);
digitalWrite(leftMotorPin_2,HIGH);
}
Else {}
digitalWrite(leftMotorPin_1,HIGH);
digitalWrite(leftMotorPin_2,LOW);
}
Sets pasadores motores derecho a girar en la dirección deseada
Si (valueRight < 0) {}
digitalWrite(rightMotorPin_1,LOW);
digitalWrite(rightMotorPin_2,HIGH);
}
Else {}
digitalWrite(rightMotorPin_1,HIGH);
digitalWrite(rightMotorPin_2,LOW);
}
Mapas de valores "w" a la gama más amplia que el motor responde a
valueLeft = map(abs(valueLeft), 100, 0, 0, 255);
valueRight = map(abs(valueRight), 100, 0, 0, 255);
analogWrite(servoPinLeft,valueLeft);
analogWrite(servoPinRight,valueRight);
}
stopTime=millis() + maxRunTime; Establecer tiempo para detener la ejecución basada en el tiempo permitido
volver stopTime;
}
Detener el bot
void stopBot() {}
driveWheels(0,0);
digitalWrite (ledPin, LOW); Apagar el LED
Si (depuración) {Serial.println ("parar ambas ruedas");}
serialReply ("i", "st"); Decirle al teléfono que el robot parado
}
Leer y procesar los valores de un telémetro ultrasónico (puede dejar este código incluso si no tienes uno)
largo getDistanceSensor(int ultrasonicPin) {}
Tomar lecturas múltiples y los promedio de
microsegundos = 0;
para (muestra de int = 1; muestra < = rangeSampleCount; muestra ++) {}
La paralaje PING))) es accionada por un pulso alto de 2 o más microsegundos.
Dar un breve impulso de baja previamente para asegurar un pulso limpio alto:
El Maxsonar parece no necesita esta parte pero no hace daño ya sea
pinMode (ultrasonicPin, salida);
digitalWrite (ultrasonicPin, bajo);
delayMicroseconds(2);
digitalWrite (ultrasonicPin, HIGH);
delayMicroseconds(5);
digitalWrite (ultrasonicPin, bajo);
El mismo pin se utiliza para leer la señal del detector ultrasónico: una alta
pulso cuya duración es el tiempo (en microsegundos) de envío
del ping a la recepción de su eco de un objeto.
pinMode (ultrasonicPin, entrada);
microsegundos += pulseIn (ultrasonicPin, HIGH);
delayMicroseconds(5); Muy breve pausa entre las lecturas
}
microsegundos = microsegundos / rangeSampleCount;
Convertir el sensor promedio lectura a centímetros y volver
cm = microsecondsToCentimeters(microseconds);
pulgadas = microsecondsToInches(microseconds);
Si {} (depuración)
Serial.Print ("Micro:"); Serial.Print(microSeconds);
Serial.Print ("pulgadas:"); Serial.Print(inches);
Serial.Print ("cm:"); Serial.println(cm);
}
volver cm;
}
largo microsecondsToCentimeters(long microseconds) {}
La velocidad del sonido es 340 m/s o 29 microsegundos por centímetro.
El ping viaja hacia fuera y hacia atrás, para encontrar la distancia de la
objeto que tomamos la mitad de la distancia recorrida.
volver microsegundos / 29 / 2;
}
largo microsecondsToInches(long microseconds) {}
Según ficha técnica de paralaje para el PING))), hay
73,746 microsegundos por pulgada (es decir, el sonido viaja a 1130 pies por
en segundo lugar). Esto da la distancia recorrida por el ping, saliente
y, por lo que dividimos por 2 para obtener la distancia del obstáculo.
Ver: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
Mismo es cierto para el MaxSonar por MaxBotix
volver microsegundos / 74 / 2;
}
Responde a en serie y maneja la pausa y descarga los datos para hacer frente a Android Comunicación serial
{} void serialReply (char * sensorname, char * tmpmsg)
Serial.Print(sensorname);
Serial.Print(":");
Serial.println(tmpmsg); Enviar el mensaje nuevamente hacia afuera de la línea serie
Espere a que el depurador serial a callarse
Delay(200); Este es un número mágico
Serial.Flush(); borra todos los datos de entrada
}
Comprueba Distanciómetros para ver si es seguro continuar en movimiento (* es necesario añadir la forma de saber qué dirección estamos Moviendonos *)
Boolean safeToProceed() {}
seguro boolean = false; Asumir que no es seguro continuar
Compruebe la distancia hasta el objeto más cercano al frente del bot y parar si demasiado
Si (rangeToObjectMargin! = 0) {/ / no te molestes en enviar si margen se establece en cero porque cuelga cuando ningún sensor presente
Dist = getDistanceSensor(rangePinForward);
Si (dist > rangeToObjectMargin) {}
seguro = true;
}
else if (depuración) {Serial.print ("objeto demasiado cerca en frente -");}
}
Comprobar la distancia a la tierra delante del bot para asegurarse de que la mesa todavía está allí
Si (rangeToGroundMargin! = 0) {/ / no te molestes en enviar si margen se establece en cero porque cuelga cuando ningún sensor presente
Dist = getDistanceSensor(rangePinForwardGround);
Si (dist > rangeToGroundMargin) {}
seguro = true;
}
else if (depuración) {Serial.print ("fin de superficie alcanzada -");}
}
Si (rangeToGroundMargin == 0 & & rangeToObjectMargin == 0) {devuelve true;}
retorno seguro;
}
Compruebe si ha transcurrido suficiente tiempo para detener el bot y si es seguro continuar
void checkIfStopBot() {}
Si (no servosForcedActive y servosActive y (stopTime < millis() o no safeToProceed())) {}
stopBot();
servosActive = false;
} else if (no safeToProceed()) {}
stopBot();
servosActive = false;
}
}
Enviar comando al dispositivo Bluetooth conectado para iniciar la sincronización
void pairBluetooth() {}
Serial.Print("\r\n+INQ=1\r\n"); Se trata de Seeedstudio maestro/esclavo (modificar según sea necesario para su modelo)
}
Lee entrada en serie si está disponible y analiza el comando cuando se ha enviado el comando completo.
void readSerialInput() {}
serialAvail = Serial.available();
Leer lo que está disponible
para (int i = 0; i < serialAvail; i ++) {}
Almacenar en búfer.
inBytes [+ serialIndex] = Serial.read();
Busque el final del comando.
Si (inBytes [+ serialIndex] == '\n' || inBytes [+ serialIndex] == ';' || inBytes [+ serialIndex] == ' >') {//Use; cuando se utiliza Monitor Serial
inBytes [+ serialIndex] = '\0'; final de caracteres de cadena
parseCommand(inBytes);
serialIndex = 0;
}
Else {}
esperaba más del comando para venir más tarde.
serialIndex += serialAvail;
}
}
}
Limpia y analiza el comando
void parseCommand(char* com) {}
Si (com [0] == '\0') {vuelta}; //bit de comprobación de errores
int Inicio = 0;
comenzar del comando
mientras que (com [Inicio]! = ' <') {}
Inicio ++;
Si (com [Inicio] == '\0') {}
no hay. Debe ser versión antigua
Inicio = -1;
rotura;
}
}
Inicio ++;
Cambiar de puesto al principio
int i = 0;
mientras que (com [i + start - 1]! = '\0') {}
com [i] = com [start + i];
i ++;
}
performCommand(com);
}
void performCommand(char* com) {}
Si (strcmp (com, "f") == 0) {/ / adelante
stopTime = driveWheels (speedMultiplier * speedMultiplier 10 * 10);
servosActive = true;
} else if (strcmp (com, "r") == 0) {/ / derecha
stopTime = driveWheels (speedMultiplier * 10, speedMultiplier * -10);
servosActive = true;
} else if (strcmp (com, "l") == 0) {/ / izquierda
stopTime = driveWheels (speedMultiplier * -10, speedMultiplier * 10);
servosActive = true;
} else if (strcmp (com, "b") == 0) {/ / al revés
stopTime = driveWheels (speedMultiplier * -10, speedMultiplier * -10);
servosActive = true;
} else if (strcmp (com, "s") == 0) {/ / Stop
stopBot();
servosActive = false;
} else if (strcmp (com, "fr") == 0 || strcmp (com, "fz") == 0 || strcmp (com, "x") == 0) {/ / lectura y avance impresión frente a distancia
Dist = getDistanceSensor(rangePinForward);
itoa (dist, msg, 10); Vuelven lo dist int a char
serialReply ("x", msg); Enviar la distancia a la línea serie
} else if (strcmp (com, "z") == 0) {/ / lectura y tierra impresión frente a distancia
Dist = getDistanceSensor(rangePinForwardGround);
itoa (dist, msg, 10); Vuelven lo dist int a char
serialReply ("z", msg); Enviar la distancia a la línea serie
} else if (strcmp (com, "h") == 0) {/ / ayuda modo - depuración de palanca
Imprima algunas instrucciones básicas al girar primero en depuración
Si (no depurar) {}
Serial.println ("dispuesto a escuchar a los comandos! Trate de lgunos de estos: ");
Serial.println ("F (adelante), B (hacia atrás), L (izquierda), R (derecha), S (parada), D (demo)");
Serial.println ("también uso números 1-9 para ajustar la velocidad (0 = lento, 9 = rápido).");
}
DEBUGGING =! DE DEPURACIÓN;
} else if (strcmp (com, "1") == 0 || strcmp (com, "2") == 0 || strcmp (com, "3") == 0 || strcmp (com, "4") == 0 || strcmp (com, "5") == 0 || strcmp (com, "6") == 0 || strcmp (com, "7") == 0 || strcmp (com, "8") == 0 || strcmp (com, "9") == 0 || strcmp (com, "0") == 0) {}
Sé la condición de precedente es chunga pero que va a cambiar pronto
Si (depuración) {Serial.print ("velocidad de cambio a");}
int i = com [0];
speedMultiplier = i - 48; Establece el multiplicador de velocidad en un rango de 1-10 de entradas ASCII 0-9
EEPROM.write (EEPROM_speedMultiplier, speedMultiplier);
Si (depuración) {Serial.println(speedMultiplier);}
Parpadeo del LED para confirmar la nueva configuración de velocidad
para (int speedBlink = 1; speedBlink < = speedMultiplier; speedBlink ++) {}
digitalWrite (ledPin, HIGH); prende el LED
Delay(100);
digitalWrite (ledPin, LOW); fijar el LED apagado
Delay(100);
}
} else if (com [0] == 'c') {/ / calibrar centro de configuración del PWM para ambos servos ex: "c 90 90"
int valueLeft = valueRight 90 = 90;
sscanf (com, "c %d %d" & valueLeft & valueRight); Analizar la contribución de varios valores
servoCenterLeft = valueLeft;
servoCenterRight = valueRight;
stopTime = driveWheels(0,0); Manejar los servos con el valor 0 que debe resultar en ningún movimiento calibrado correctamente
servosActive = true;
EEPROM.write (EEPROM_servoCenterLeft, servoCenterLeft);
EEPROM.write (EEPROM_servoCenterRight, servoCenterRight);
Si {} (depuración)
Serial.Print ("calibrado servo centros para");
Serial.Print(servoCenterLeft);
Serial.Print ("y");
Serial.println(servoCenterRight);
}
} else if (strcmp (com, "i") == 0) {/ / cambiar el servo a modo activo infinito así que hace tiempo no automáticamente
servosForcedActive =! servosForcedActive; Sólo cuando es peligroso
EEPROM.write (EEPROM_servosForcedActive, servosForcedActive);
Si {} (depuración)
Serial.Print ("infinito rotación activada a");
Si (servosForcedActive){Serial.println("on");}
Else {Serial.println("off");}
}
} else if (com [0] == 'w') {/ / manejar el mando de la "rueda" y se traducen en valores PWM ex: "w-100 100" [rango es de -100 a 100]
int valueLeft = valueRight 90 = 90;
sscanf (com, «w %d %d» & valueLeft & valueRight); Analizar la contribución de varios valores
stopTime = driveWheels (valueLeft, valueRight);
servosActive = true;
} else if (strcmp (com, "reset") == 0) {/ / resetea los valores de la eeprom
setEepromsToDefault();
} else if (com [0] == ' n ') {/ / mover la cabeza hacia arriba
sscanf (com, «n %d» & lastNeckValue); Analizar la contribución de varios valores
myservoHead.attach(servoPinHead);
myservoHead.write(lastNeckValue);
EEPROM.write (EEPROM_lastNeckValue, lastNeckValue);
Si {} (depuración)
Serial.Print ("cuello a");
Serial.println(lastNeckValue);
}
} else if (com [0] == 'p') {/ / inicia Bluetooth emparejamiento así que otro dispositivo se puede conectar
pairBluetooth();
} else {}
serialReply ("e", com); / / Echo comando desconocido nuevo
Si {} (depuración)
Serial.Print ("comando desconocido:");
Serial.println(com);
}
}
}
Bucle principal funcionando en todo momento
void loop()
{
readSerialInput();
checkIfStopBot();
}
