Stap 2: De Code deel 1
De Code die wordt gebruikt voor dit systeem is gecentreerd rond de bibliotheek van de "RCArduinoFastLib"; gemaakt door "Can_I_Trade" van de "RCArduino" blog. Dit is een uitstekende bibliotheek die niet alleen lost de problemen met het lezen van signalen van de servo maar omvat ook de code die nodig is voor het verzenden van signalen naar de servo's aswell.U kunt meer lezen over de bibliotheek hier.
De kop- en CPP bestand zijn gekoppeld aan deze pagina dus gewoon een bestand genaamd RCArduinoFastLib in uw omslag van bibliotheken voor de arduino IDE en deze 2 bestanden vallen.
Opmerking: Ik heb niet de "PinChangeInt" bibliotheek geïnstalleerd ofwel dus u kan nodig zijn om te downloaden en zet dat in uw omslag van Bibliotheken evenals om succesvol het compileren van de code van de Arduino.
Dit codevoorbeeld hieronder ziet u hetzelfde voorbeeld als wordt geleverd met de bibliotheek, zo heel eenvoudig kan ik niet beter, hoewel later in de instructable u de wijzigingen die ik gemaakt ziet heb om de invloed van servo posities op basis van externe voorwaarden en om het meer voor mijn gebruik te maken. Deze voorbeeldcode is enkel een eenvoudige doorheen reiszak die veranderen de signalen van de ontvanger op geen enkele manier helemaal niet zal, waardoor wij om de integriteit van het circuit dat we maken en oplossen van problemen gemakkelijker te controleren. Het is momenteel ingesteld om controle 3 signaallijnen (in dit genoemd: THROTTLE, stuur en AUX) dus als u meer voeg ze in de code vereisen met dezelfde opmaak zoals wordt gebruikt in de regels voor de huidige signalen.
Excuses voor de tekstindeling zonder opmaak maar ik weet niet hoe maak je een vak code hier: P Kopieer het naar de Arduino IDE voor een betere leesbaarheid (als iemand commentaar op hoe dit te doen, dan zal ik bewerken:-P).
Gelieve Vergeet niet om te lezen van de commentaren zodat het duidelijk over wat de code doet
#include < RCArduinoFastLib.h >
MultiChannels
//
rcarduino.blogspot.com
//
Een eenvoudige benadering voor het lezen van drie kanalen van de RC met behulp van de pin wijzigen interrupts
//
Zie Verwante posten-
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
//
de bibliotheek pinchangeint - Zie de koppelingen in het gedeelte ' Verwante onderwerpen ' hierboven voor meer informatie
#include < PinChangeInt.h >
Toewijzen van uw kanaal in pinnen
#define THROTTLE_IN_PIN 5
#define STEERING_IN_PIN 6
#define AUX_IN_PIN 7
Toewijzen van uw kanaal uit pinnen
#define THROTTLE_OUT_PIN 8
#define STEERING_OUT_PIN 9
#define AUX_OUT_PIN 10
Toewijzen van servo indexen
#define SERVO_THROTTLE 0
#define SERVO_STEERING 1
#define 2
#define SERVO_FRAME_SPACE 3
Deze vlaggen bits zijn ingesteld in de bUpdateFlagsShared om aan te geven die
kanalen hebben nieuwe signalen
#define THROTTLE_FLAG 1
#define STEERING_FLAG 2
#define AUX_FLAG 4
houdt de vlaggen van de update hierboven omschreven
vluchtige uint8_t bUpdateFlagsShared;
gedeelde variabelen worden bijgewerkt door de ISR en gelezen door de lus.
In lus we nu nemen lokale kopieën zodat de ISR kan blijven eigendom van de
gedeelde ones. Voor toegang tot deze in lus we eerst uitschakelen onderbreekt met noInterrupts
We nemen een kopie te gebruiken in de lus en de turn interrupts terug op zo spoedig mogelijk
Dit zorgt ervoor dat we kunnen altijd nieuwe signalen ontvangen
vluchtige uint16_t unThrottleInShared;
vluchtige uint16_t unSteeringInShared;
vluchtige uint16_t unAuxInShared;
Deze worden gebruikt om vast te leggen van de stijgende rand van een puls in de calcInput-functies
Ze hoeven niet te worden vluchtige zoals ze alleen in de ISR. gebruikt worden Als we wilden
Als u wilt verwijzen naar deze in de loop en de ISR zou dan zij moeten worden verklaard vluchtige
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");
hechten servo objecten, deze zorgt voor de juiste
pulsen voor het besturen van elektronische snelheidsregelaars, servo's of andere apparaten
ontworpen om te communiceren rechtstreeks met RC ontvangers
CRCArduinoFastServos::attach(SERVO_THROTTLE,THROTTLE_OUT_PIN);
CRCArduinoFastServos::attach(SERVO_STEERING,STEERING_OUT_PIN);
CRCArduinoFastServos::attach(SERVO_AUX,AUX_OUT_PIN);
laat een standaardtarief van 50 Hz instellen door de instelling van een ruimte van de frame van 10 * 2000 = 3 Servos + 7 keer 2000
CRCArduinoFastServos::setFrameSpaceA(SERVO_FRAME_SPACE,7*2000);
CRCArduinoFastServos::begin();
met behulp van de PinChangeInt-bibliotheek, hechten de interrupts gebruikt om te lezen van de kanalen
PCintPort::attachInterrupt (THROTTLE_IN_PIN, calcThrottle, verandering);
PCintPort::attachInterrupt (STEERING_IN_PIN, calcSteering, verandering);
PCintPort::attachInterrupt (AUX_IN_PIN, calcAux, verandering);
}
void loop
{
lokale variabelen voor het opslaan van een lokale kopieën van de ingangen van het kanaal maken
deze worden gedeclareerd statische zodat hun waarden tussen aanroepen van lus zal worden bewaard.
statisch uint16_t unThrottleIn;
statisch uint16_t unSteeringIn;
statisch uint16_t unAuxIn;
lokale kopie van update vlaggen
statische uint8_t bUpdateFlags;
controleren van gedeelde update vlaggen om te zien of alle kanalen een nieuw signaal
if(bUpdateFlagsShared)
{
noInterrupts(); uitschakelen onderbreekt snel terwijl we lokale kopieën van de gedeelde variabelen nemen
nemen van een lokale kopie van die kanalen zijn bijgewerkt in het geval dat we nodig hebben om dit te gebruiken in de rest van de lus
bUpdateFlags = bUpdateFlagsShared;
in de huidige code, worden de gedeelde waarden altijd gevuld
dus we hen kunnen kopiëren zonder het testen van de vlaggen
echter in de toekomst kan dit veranderen, dus laat
alleen kopiëren wanneer de vlaggen vertellen ons dat we kunnen.
if(bUpdateFlags & THROTTLE_FLAG)
{
unThrottleIn = unThrottleInShared;
}
if(bUpdateFlags & STEERING_FLAG)
{
unSteeringIn = unSteeringInShared;
}
if(bUpdateFlags & AUX_FLAG)
{
unAuxIn = unAuxInShared;
}
Schakel gedeelde kopie van updated vlaggen zoals we al de updates hebben
We hebben nog een lokale kopie als we nodig hebben om het te gebruiken in bUpdateFlags
bUpdateFlagsShared = 0;
interrupts(); We hebben van de lokale kopieën van de ingangen, dus nu kunnen wij draaien onderbreekt terug op
Zodra er zijn interrupts terug op, kunnen we niet langer gebruiken de gedeelde exemplaren, de interrupt
dienst routines eigen deze en kunnen ze op elk gewenst moment bijwerken. Tijdens de update, de
gedeelde kopieën kunnen ongewenste bevatten. Gelukkig hebben wij onze lokale kopieën om mee te werken :-)
}
doen van elke vorm van verwerking vanaf hier verder
Gebruik alleen de lokale waarden unAuxIn, unThrottleIn en unSteeringIn, de gedeelde
variabelen unAuxInShared, unThrottleInShared, unSteeringInShared zijn altijd eigendom van
de interrupt routines en mag niet worden gebruikt in de lus
de volgende code biedt eenvoudige doorheen dit is een goede eerste test
de Arduino zal passeren ontvanger input alsof de Arduino er niet is.
Dit moet worden gebruikt voor het bevestigen van het circuit en de macht
voordat u probeert een aangepaste verwerking in een project.
We controleren om te zien als de waarde van het kanaal is gewijzigd, wordt dit aangegeven
door de vlaggen. Voor de eenvoudige passeren we niet echt nodig dit controle,
maar voor een meer complexe project waar een nieuw signaal aanzienlijke vereist verwerking
Dit laat ons toe om alleen nieuwe waarden berekenen wanneer er nieuwe ingangen, eerder dan
op elke cyclus.
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;
}
eenvoudige interrupt service routine
VOID calcThrottle()
{
if(PCintPort::pinState)
{
unThrottleInStart = TCNT1;
}
anders
{
unThrottleInShared = (TCNT1 - unThrottleInStart) >> 1;
bUpdateFlagsShared | = THROTTLE_FLAG;
}
}
VOID calcSteering()
{
if(PCintPort::pinState)
{
unSteeringInStart = TCNT1;
}
anders
{
unSteeringInShared = (TCNT1 - unSteeringInStart) >> 1;
bUpdateFlagsShared | = STEERING_FLAG;
}
}
VOID calcAux()
{
if(PCintPort::pinState)
{
unAuxInStart = TCNT1;
}
anders
{
unAuxInShared = (TCNT1 - unAuxInStart) >> 1;
bUpdateFlagsShared | = AUX_FLAG; }
}
