Étape 5: La partie de Code 2
Vous pouvez utiliser quelque capteur que vous aimez et autant que vous le souhaitez, tant qu’ils peuvent s’interfacer avec l’arduino que vous utilisez.
Pour illustrer cette idée, j’ai écrit un code qui prend un représentant de la lecture de la distance à un analogue SHARP capteur Infra-rouge qui est monté sur un côté de l’hélicoptère, et si la lecture implique que l’hélicoptère est presque un obstacle puis il va être déviée vers le côté opposé. Dans le cas contraire le contrôle restera entièrement sur nos mains.
J’ai laissé le code de la manette des gaz en malgré le fait qu’il n’est pas utilisé dans le cas où vous utilisez une 3ème ligne de signal ; il vous permettra d’économiser temps, ajouter le code de retour dans:) ne sont pas j’ai beau !
Voici la mis à jour le Code et n’oubliez pas à lire les commentaires pour le rendre clair quant à ce que le code est :
#include < RCArduinoFastLib.h >
//
Code d’exemple Mod à the Origional Test Structure de RCArduino du capitaine Dyson
pour la bibliothèque « RCArduinoFastLib »
Copiez le code suivant lit un capteur de distance avant de décider s’il faut déplacer loin ou non.
//
Multicanaux
rcarduino.blogspot.com
Une approche simple pour la lecture des trois canaux RC à l’aide de la goupille de changer des interruptions
Voir les messages connexes-
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
inclure la bibliothèque de pinchangeint - voir les liens dans la section Rubriques connexes ci-dessus pour plus de détails
#include < PinChangeInt.h >
Assigner votre canal à pins
#define THROTTLE_IN_PIN 5
#define STEERING_IN_PIN 6
#define AUX_IN_PIN 7
Assigner votre canal des pins
#define THROTTLE_OUT_PIN 8
#define STEERING_OUT_PIN 9
#define AUX_OUT_PIN 10
Attribuer servo index
#define SERVO_THROTTLE 0
#define SERVO_STEERING 1
#define 2
#define SERVO_FRAME_SPACE 3
Ces indicateurs de bits sont définis dans bUpdateFlagsShared pour indiquer quels sont les canaux ont des nouveaux signaux
#define THROTTLE_FLAG 1
#define STEERING_FLAG 2
#define AUX_FLAG 4
contient des indicateurs de mise à jour définis ci-dessus
bUpdateFlagsShared uint8_t volatils ;
variables partagées sont mis à jour par l’ISR et lire en boucle.
Dans le boucle nous, immédiatement prendre des copies locales afin que le rapport de recherche internationale peut garder la propriété de la
ceux partagés. Pour accéder aux suivantes en boucle nous couper d’abord interruptions avec noInterrupts
Nous prenons une copie à utiliser dans la boucle et le tour interruptions sur dès que possible
Cela garantit que nous sommes toujours en mesure de recevoir de nouveaux signaux
unThrottleInShared uint16_t volatils ;
unSteeringInShared uint16_t volatils ;
unAuxInShared uint16_t volatils ;
Ils servent à enregistrer le front montant d’une impulsion dans les fonctions calcInput
Ils ne faut pas être volatile car elles servent uniquement à la sûreté. Si nous voulions
pour faire référence à ces derniers dans la boucle et l’ISR alors ils auraient besoin d’être déclarée volatile
uint16_t unThrottleInStart ;
uint16_t unSteeringInStart ;
uint16_t unAuxInStart ;
uint16_t unLastAuxIn = 0 ;
uint32_t ulVariance = 0 ;
uint32_t ulGetNextSampleMillis = 0 ;
uint16_t unMaxDifference = 0 ;
Assigner un NIP pour lire les données du capteur
int sensorPin = A0 ;
void setup()
{
Serial.Begin(115200) ;
Serial.println("multiChannels") ;
Attachez des objets servo, il vont générer le bon
impulsions pour la conduite des servos, des variateurs électroniques ou autres dispositifs
conçue pour s’interfacer directement avec les récepteurs de RC
CRCArduinoFastServos::attach(SERVO_THROTTLE,THROTTLE_OUT_PIN) ;
CRCArduinoFastServos::attach(SERVO_STEERING,STEERING_OUT_PIN) ;
CRCArduinoFastServos::attach(SERVO_AUX,AUX_OUT_PIN) ;
permet de définir un taux standard de 50 Hz en définissant un espace de trame de 10 * 2000 = 3 Servos + 2000 7 fois
CRCArduinoFastServos::setFrameSpaceA(SERVO_FRAME_SPACE,7*2000) ;
CRCArduinoFastServos::begin() ;
à l’aide de la bibliothèque PinChangeInt, fixez les interruptions utilisées pour lire les canaux
PCintPort::attachInterrupt (THROTTLE_IN_PIN, calcThrottle, changement) ;
PCintPort::attachInterrupt (STEERING_IN_PIN, calcSteering, changement) ;
PCintPort::attachInterrupt (AUX_IN_PIN, calcAux, changement) ;
}
void loop()
{
Créez des variables locales pour tenir des copies locales des entrées canal
ceux-ci sont déclarés statiques afin que leurs valeurs seront conservées entre les appels à boucle.
public static uint16_t unThrottleIn ;
public static uint16_t unSteeringIn ;
public static uint16_t unAuxIn ;
copie locale des indicateurs de mise à jour
bUpdateFlags uint8_t statique ;
vérifier les indicateurs partagés mise à jour pour voir si tous les canaux ont un nouveau signal
if(bUpdateFlagsShared)
{
noInterrupts() ; mettre les interruptions hors rapidement tandis que nous prenons des copies locales des variables partagées
prendre une copie locale dont les canaux ont été mis à jour dans le cas où nous avons besoin de l’utiliser dans le reste de la boucle
bUpdateFlags = bUpdateFlagsShared ;
dans le code actuel, les valeurs partagées sont toujours remplis
donc nous pourrions copier sans tester les drapeaux
Cependant à l’avenir, cela pourrait changer, laisse ainsi
Copiez uniquement quand les drapeaux nous disent que nous pouvons.
if(bUpdateFlags & THROTTLE_FLAG)
{
unThrottleIn = unThrottleInShared ;
}
if(bUpdateFlags & STEERING_FLAG)
{
unSteeringIn = unSteeringInShared ;
}
if(bUpdateFlags & AUX_FLAG)
{
unAuxIn = unAuxInShared ;
}
Désactivez la copie partagée des indicateurs mis à jour parce que nous avons déjà pris les mises à jour
Nous avons encore une copie locale, si nous avons besoin de l’utiliser dans bUpdateFlags
bUpdateFlagsShared = 0 ;
interrupts() ; Nous avons des copies locales des entrées, interrompt alors maintenant nous pouvons tourner sur
dès que les interruptions sont de retour sur, nous pouvons utiliser n’est plus les copies partagées, l’interruption
routines de service ces propres et pourraient mettre à jour à tout moment. Au cours de la mise à jour, le
copies partagées peuvent contenir indésirable. Heureusement, nous avons nos copies locales de travailler avec:-)
}
procéder à tout traitement à partir de là
Utilisez uniquement les valeurs locales unAuxIn, les unThrottleIn et les unSteeringIn
Cette configuration capteur détecte la présence d’un objet vers la droite de helecopters
Si l’objet est de fermer puis le métier va dévier à gauche, loin du danger
Vous pouvez ajouter autant si boucles dans ce code que vous aiment avec différents capteurs
mais s’il vous plaît ne pas copier ce code exactement et espérer qu’il fonctionne, tout dépend
les détails de vos servos et les orientations souhaitées se déplacer
Ce code est spécifique à ma carrure, modifiez-le pour vôtre:)
Lire le capteur
int val = analogRead(sensorPin) ;
Placez une condition contre cette lecture
Si (val > 150)
{
agir sur la condition
unSteeringIn = unSteeringIn + 430 ;
Appliquer les nouvelles valeurs modifiées
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 nous n’avons aucune raison de modifier la position du servo, alors nous pouvons passer le signal par l’intermédiaire
comme nous l’avons fait dans le sketch de test avec aucune altération.
d’autre
{
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 ;
}
routine d’interruption simple du service
Sub calcThrottle()
{
if(PCintPort::pinState)
{
unThrottleInStart = TCNT1 ;
}
d’autre
{
unThrottleInShared = (TCNT1 - unThrottleInStart) >> 1 ;
bUpdateFlagsShared | = THROTTLE_FLAG ;
}
}
Sub calcSteering()
{
if(PCintPort::pinState)
{
unSteeringInStart = TCNT1 ;
}
d’autre
{
unSteeringInShared = (TCNT1 - unSteeringInStart) >> 1 ;
bUpdateFlagsShared | = STEERING_FLAG ;
}
}
Sub calcAux()
{
if(PCintPort::pinState)
{
unAuxInStart = TCNT1 ;
}
d’autre
{
unAuxInShared = (TCNT1 - unAuxInStart) >> 1 ;
bUpdateFlagsShared | = AUX_FLAG ; }
}
Maintenant n’oubliez pas que c’est juste un exemple simple, s’il vous plaît être aussi inventifs que vous le souhaitez et ajouter autant de capteurs comme vous, comme, quelques idées seraient un accéléromètre et un capteur de PING pour la détection des distances plus longues, ou aller encore plus loin et ajoute un GPS avec un emplacement actuel vs comparaison emplacement cible puis obtenir votre appareil pour aller à un emplacement géographique spécifique.
