Paso 5: El código parte 2
Usted puede utilizar cualquier sensor que te gusta y tantos como quieras, siempre y cuando puede interactuar con el arduino que está utilizando.
Para demostrar esta idea, he escrito algo de código que tiene a un representante de la lectura de la distancia de un análogo de la SHARP sensor de infrarrojos que se monta sobre un lado del helicóptero y si la lectura implica que el helicóptero está a punto de un obstáculo entonces va desviar apagado al lado opuesto. De lo contrario seguirá siendo control enteramente en nuestras manos.
He dejado el código de la válvula reguladora en a pesar de que no se utiliza en caso de que usted está usando una línea de señal de 3; le ahorrará tiempo añadiendo el código nuevo :) no me agradable!
Aquí está el modificado Código y recuerde por favor leer los comentarios para que sea claro en cuanto a lo que el código hace:
#include < RCArduinoFastLib.h >
//
Código de ejemplo Mod a la original prueba estructura de RCArduino de capitán Dyson
para la biblioteca "RCArduinoFastLib"
Este código Lee un sensor de distancia antes de decidir si mover lejos o no.
//
MultiChannels
rcarduino.blogspot.com
Un enfoque simple para la lectura de tres canales RC con pasador de cambio interrupciones
Ver entradas relacionadas-
http://rcarduino.blogspot.co.uk/2012/01/How-to-read-RC-Receiver-with.html
http://rcarduino.blogspot.co.uk/2012/03/Need-More-Interrupts-to-read-more.html
http://rcarduino.blogspot.co.uk/2012/01/Can-i-control-more-than-x-servos-with.html
rcarduino.blogspot.com
incluir la biblioteca de pinchangeint - vea los enlaces en la sección temas relacionados para obtener más información
#include < PinChangeInt.h >
Asignar el canal en pins
#define THROTTLE_IN_PIN 5
#define STEERING_IN_PIN 6
#define AUX_IN_PIN 7
Asignar el canal a pernos
#define THROTTLE_OUT_PIN 8
#define STEERING_OUT_PIN 9
#define AUX_OUT_PIN 10
Asignar índices de servo
#define SERVO_THROTTLE 0
#define SERVO_STEERING 1
#define 2
#define SERVO_FRAME_SPACE 3
Estos indicadores de bit se encuentran en bUpdateFlagsShared para indicar que los canales tienen nuevas señales
#define THROTTLE_FLAG 1
#define STEERING_FLAG 2
#define AUX_FLAG 4
sostiene las banderas de actualización definidas anteriormente
bUpdateFlagsShared de uint8_t volátiles;
variables compartidas son actualizadas por el ISR y leídas por lazo.
En bucle inmediatamente tome las copias locales para que la ISR puede mantener la propiedad de la
los compartidos. Para acceder a estas en bucle primero apagamos interrupciones con noInterrupts
tomamos una copia para utilizar en bucle y la vuelta interrupciones en cuanto antes
Esto asegura que siempre somos capaces de recibir nuevas señales
unThrottleInShared de uint16_t volátil;
unSteeringInShared de uint16_t volátil;
unAuxInShared de uint16_t volátil;
Estos se utilizan para registrar el flanco ascendente de pulso en las funciones calcInput
No deben ser volátiles como sólo se utilizan en el ISR Si quisiéramos
para hacer referencia a éstos en el lazo y el ISR entonces tendrían que ser declarados volátiles
unThrottleInStart de uint16_t;
unSteeringInStart de uint16_t;
unAuxInStart de uint16_t;
uint16_t unLastAuxIn = 0;
ulVariance de uint32_t = 0;
ulGetNextSampleMillis de uint32_t = 0;
uint16_t unMaxDifference = 0;
Asignar un pasador para leer los datos de sensor (es)
int sensorPin = A0;
void setup()
{
Serial.Begin(115200);
Serial.println("multiChannels");
adjuntar objetos de servo, se generan el correcto
pulsos para la conducción de controladores de velocidad electrónicos, servos y otros dispositivos
diseñado para interactuar directamente con receptores RC
CRCArduinoFastServos::attach(SERVO_THROTTLE,THROTTLE_OUT_PIN);
CRCArduinoFastServos::attach(SERVO_STEERING,STEERING_OUT_PIN);
CRCArduinoFastServos::attach(SERVO_AUX,AUX_OUT_PIN);
permite establecer una tasa estándar de 50 Hz mediante el establecimiento de un espacio del marco de 10 * 2000 = 3 Servos + 2000 7 veces
CRCArduinoFastServos::setFrameSpaceA(SERVO_FRAME_SPACE,7*2000);
CRCArduinoFastServos::begin();
usando la biblioteca PinChangeInt, coloque las interrupciones para leer los canales
PCintPort::attachInterrupt (THROTTLE_IN_PIN, calcThrottle, cambio);
PCintPort::attachInterrupt (STEERING_IN_PIN, calcSteering, cambio);
PCintPort::attachInterrupt (AUX_IN_PIN, calcAux, cambio);
}
void loop()
{
crear variables locales para sostener una copias locales de las entradas de canal
Estas se declaran estáticas que se conservarán sus valores entre llamadas a lazo.
unThrottleIn de uint16_t estáticos;
unSteeringIn de uint16_t estáticos;
unAuxIn de uint16_t estáticos;
copia local de indicadores de actualización
bUpdateFlags de uint8_t estática;
Ver banderas de actualización compartida para ver si los canales tienen una nueva señal
if(bUpdateFlagsShared)
{
noInterrupts(); desactivar interrupciones rápidamente mientras tomamos copias locales de las variables compartidas
tomar una copia local de que los canales fueron actualizados en caso de necesitar utilizar este en el resto del bucle
bUpdateFlags = bUpdateFlagsShared;
en el código actual, los valores compartidos están siempre poblados
así podríamos copiarlos sin pruebas las banderas
sin embargo en el futuro esto podría cambiar, así que vamos a
copiar sólo cuando los indicadores nos dicen que podemos.
if(bUpdateFlags & THROTTLE_FLAG)
{
unThrottleIn = unThrottleInShared;
}
if(bUpdateFlags & STEERING_FLAG)
{
unSteeringIn = unSteeringInShared;
}
if(bUpdateFlags & AUX_FLAG)
{
unAuxIn = unAuxInShared;
}
claro la copia compartida de indicadores actualizados como ya hemos tomado las actualizaciones
todavía tenemos una copia local si necesitamos usarlo en bUpdateFlags
bUpdateFlagsShared = 0;
Interrupts(); tenemos copias locales de las entradas, así que ahora podemos convertir interrumpe en
tan pronto como las interrupciones son nuevo, ya no podemos usar las copias compartidas, la interrupción
rutinas de servicio propias de estos y pueden actualizar en cualquier momento. Durante la actualización, la
copias compartidas pueden contener basura. Por suerte tenemos nuestras copias locales para trabajar con :-)
}
hacer cualquier procesamiento de aquí en adelante
Utilice únicamente los valores locales unAuxIn, unThrottleIn y unSteeringIn
Esta configuración de Sensor detecta la presencia de un objeto a la derecha de helecopters
Si el objeto es para cerrar entonces la nave se desviará izquierda, lejos del peligro
Puede agregar tantos lazos en este código que como con diferentes sensores
pero por favor no copiar este código exactamente y esperar que funcione, todo depende de la
los detalles de tus servos y las direcciones que quieras viajar
Este código es específico para mi construir, modificar para el suyo :)
Leer el Sensor
int val = analogRead(sensorPin);
colocar una condición contra esta lectura
Si (val > 150)
{
actuar de acuerdo a la condición
unSteeringIn = unSteeringIn + 430;
Aplicar los nuevos valores alterados
if(bUpdateFlags & THROTTLE_FLAG)
{
CRCArduinoFastServos::writeMicroseconds(SERVO_THROTTLE,unThrottleIn);
}
if(bUpdateFlags & STEERING_FLAG)
{
CRCArduinoFastServos::writeMicroseconds(SERVO_STEERING,unSteeringIn);
}
if(bUpdateFlags & AUX_FLAG)
{
CRCArduinoFastServos::writeMicroseconds(SERVO_AUX,unAuxIn);
}
}
Si no tenemos ninguna razón para alterar las posiciones de servo luego podemos pasar la señal a través de
como lo hicimos en el bosquejo del examen sin alteraciones.
otra cosa
{
if(bUpdateFlags & THROTTLE_FLAG)
{
CRCArduinoFastServos::writeMicroseconds(SERVO_THROTTLE,unThrottleIn);
}
if(bUpdateFlags & STEERING_FLAG)
{
CRCArduinoFastServos::writeMicroseconds(SERVO_STEERING,unSteeringIn);
}
if(bUpdateFlags & AUX_FLAG)
{
CRCArduinoFastServos::writeMicroseconds(SERVO_AUX,unAuxIn);
}
}
bUpdateFlags = 0;
}
rutina de servicio de interrupción simple
void calcThrottle()
{
if(PCintPort::pinState)
{
unThrottleInStart = TCNT1;
}
otra cosa
{
unThrottleInShared = (TCNT1 - unThrottleInStart) >> 1;
bUpdateFlagsShared | = THROTTLE_FLAG;
}
}
void calcSteering()
{
if(PCintPort::pinState)
{
unSteeringInStart = TCNT1;
}
otra cosa
{
unSteeringInShared = (TCNT1 - unSteeringInStart) >> 1;
bUpdateFlagsShared | = STEERING_FLAG;
}
}
void calcAux()
{
if(PCintPort::pinState)
{
unAuxInStart = TCNT1;
}
otra cosa
{
unAuxInShared = (TCNT1 - unAuxInStart) >> 1;
bUpdateFlagsShared | = AUX_FLAG; }
}
Ahora recuerde que esto es sólo un simple ejemplo, por favor ser tan creativo como quieras y añadir tantos sensores como usted como algunas ideas un acelerómetro y un sensor PING para detección a largas distancias, o ir aún más lejos y añadir un GPS con una ubicación actual vs comparación del lugar de destino y luego conseguir el dispositivo para ir a una ubicación geográfica específica.
