Étape 2: La Code partie 1
Le Code utilisé pour ce système est centré autour de la bibliothèque « RCArduinoFastLib » ; créée par « Can_I_Trade » du blog « RCArduino ». Il s’agit d’une excellente bibliothèque qui non seulement résout les problèmes avec la lecture des signaux de servo, mais intègre également le code requis pour envoyer des signaux à l’aswell de servos.Vous pouvez en savoir plus sur la bibliothèque ici.
Le fichier d’en-tête et le RPC sont liées à cette page, il suffit donc de le créer un fichier nommé RCArduinoFastLib dans votre dossier de bibliothèques de l’arduino IDE et supprimer ces 2 fichiers dedans.
Remarque : je n’ai pas le « PinChangeInt » bibliothèque installée soit, vous devrez peut-être télécharger et le mettre dans votre dossier de bibliothèques ainsi afin de compiler le code de l’Arduino.
Cet exemple de code ci-dessous est l’exemple même comme est livré avec la bibliothèque, comme tout simplement, je ne peux faire mieux, bien que plus tard dans l’instructable, vous verrez les modifications que j’ai fait afin d’influencer les positions servo issues des conditions extérieures et pour le rendre plus applicable à mon usage. Cet exemple de code est juste un simple passage scrip qui va changer les signaux du récepteur en rien du tout, ce qui nous permet de vérifier l’intégrité du circuit que nous créons et résoudre les problèmes plus facilement. Il est actuellement mis en place pour contrôler les 3 lignes de signal (dans ce appelé : papillon, directeur et AUX) donc si vous avez besoin plus les ajouter seulement dans le code avec la même mise en forme est utilisée dans les lignes pour les signaux de courant.
Toutes mes excuses pour le format texte brut, mais je ne sais pas comment faire pour créer une zone de code ici: P copie dans l’IDE Arduino pour faciliter la lecture (si quelqu'un commente sur la façon de le faire, alors j’ai Il éditera:-P).
S’il vous plaît n’oubliez pas de lire les commentaires pour le rendre clair quant à ce que le code ne
#include < RCArduinoFastLib.h >
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 bits sont définis dans bUpdateFlagsShared pour indiquer qui
canaux ont de 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 ;
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 le valeurs locales d’unAuxIn, unThrottleIn et unSteeringIn, la commune
les variables unAuxInShared, unThrottleInShared, unSteeringInShared sont toujours la propriété de
les routines d’interruption et ne doit pas être utilisé dans la boucle
le code suivant fournit simple passe par là est un bon test initial
l’Arduino passera à travers l’entrée de récepteur comme si l’Arduino n’est pas là.
Cela devrait être utilisé pour confirmer le circuit et la puissance
avant d’effectuer tout traitement personnalisé dans un projet.
nous vérifions pour voir si la valeur du canal a changé, c’est indiqué
par les drapeaux. Pour le simple passage dans on n’ai pas vraiment besoin de cela vérifier,
mais pour un projet plus complexe, où un nouveau signal exige importante transformation
Cela nous permet de calculer seulement nouvelles valeurs lorsque nous avons des nouvelles entrées, plutôt que
à chaque cycle.
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 ; }
}