Paso 2: Código parte 1
El código utilizado para este sistema se centra alrededor de la biblioteca "RCArduinoFastLib"; creado por "Can_I_Trade" del blog "RCArduino". Se trata de una excelente biblioteca que no sólo resuelve los problemas con la lectura de las señales del servo, pero también incorpora el código necesario para enviar señales a lo servos así.Usted puede leer más acerca de la biblioteca aquí.
El archivo de encabezado y el CPP se unen a esta página simplemente cree un archivo denominado RCArduinoFastLib en la carpeta de las bibliotecas de arduino IDE y soltar estos 2 archivos en él.
Nota: no tengo el "PinChangeInt" biblioteca instalado ya sea que tal vez necesite descargar y que poner en la carpeta de bibliotecas así como para poder realizar con éxito el código de Arduino.
Este ejemplo de código siguiente es el mismo ejemplo ya viene con la biblioteca, como simplemente no puedo hacer mejor, aunque más tarde en el instructable verás las modificaciones que he hecho con el fin de influir en posiciones de servo basados en las condiciones externas y para hacerlo más aplicable a mi uso. Este código de ejemplo es sólo un simple paso a través de scrip que va a cambiar las señales del receptor de ninguna manera, lo que nos permite comprobar la integridad del circuito que crear y resolver problemas más fácilmente. Está configurada actualmente para el control de 3 líneas de señal (en este llamado: acelerador, volante y AUX) así que si necesita más a añadir en el código con el mismo formato como se utiliza en las líneas para las señales actuales.
Disculpas por el formato de texto pero no sé cómo crear un cuadro de código aquí: P lo copie en el IDE de Arduino para facilitar la lectura (si alguien comenta sobre cómo hacer esto entonces se editarlo:-P).
Por favor recuerden leer los comentarios para que sea claro en cuanto a lo que el código hace
#include < RCArduinoFastLib.h >
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;
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 lo valores locales unAuxIn, unThrottleIn y unSteeringIn, la compartida
variables unAuxInShared, unThrottleInShared, unSteeringInShared son siempre propiedad de
las rutinas de interrupción y no debe ser utilizado en bucle
el código siguiente proporciona simple pasar es una buena prueba inicial
el Arduino pasará a través de entrada del receptor como si el Arduino no existe.
Esto debe utilizarse para confirmar el circuito y la potencia
antes de realizar cualquier procesamiento personalizado en un proyecto.
Estamos comprobando para ver si ha cambiado el valor del canal, esto se indica
por las banderas. Por el simple paso por realmente no necesita comprobar esto,
pero para un proyecto más complejo donde una nueva señal requiere significativa de procesamiento
Esto nos permite sólo calcular nuevos valores cuando tengamos nuevas entradas, en lugar de
en cada ciclo.
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; }
}
