Grunderna i förvandlar ditt Remote Controll fordon till ett autonomt System (Drone) genom att använda en Arduino (2 / 7 steg)

Steg 2: Kod del 1

Koden som används för detta system är centrerad kring "RCArduinoFastLib" biblioteket. skapad av "Can_I_Trade" från "RCArduino" blogg. Detta är ett utmärkt bibliotek som inte bara löser problem med att läsa servo signaler men också inlemmar koden krävs för att skicka signaler till servon aswell.
Du kan läsa mer om biblioteket här.
Sidhuvud och CPP filen är kopplade till den här sidan så bara skapa en fil som heter RCArduinoFastLib i mappen Bibliotek för arduino IDE och släppa dessa 2 filer till den.

Obs: Jag hade ingen "PinChangeInt" biblioteket installerat antingen så kan du behöva hämta och lägga det i mappen bibliotek samt för att framgångsrikt kompilera Arduino koden.

Denna kodexempel nedan är samma exempel som kommer med biblioteket, som helt enkelt jag inte kan göra bättre, även om senare i den instructable visas de ändringar jag har gjort för att påverka servo positioner utifrån yttre förhållanden och göra det mer tillämplig på min användning. Denna exempelkod är bara en enkel förmedlad väska som kommer att förändra signalerna från mottagaren på något sätt alls, vilket tillåter oss att kontrollera integriteten hos den krets som vi skapar och lösa problem lättare. Det är för tillfället inställd att styra 3 signalen linjer (i detta kallas: SPJÄLL, styrningen och AUX) så om du vill ha mer bara lägga dem till koden med samma formatering som används i raderna för nuvarande signaler.

Ber om ursäkt för formatet oformaterad text men jag vet inte hur man skapar en kod rutan på här: P kopierar du den till Arduino IDE för lättare läsning (om någon kommentarer på hur man gör detta så kommer jag redigera det:-P).

Vänligen kom ihåg att läsa kommentarerna för att göra det klart för oss vad koden gör

#include < RCArduinoFastLib.h >

MultiChannels
//
rcarduino.blogspot.com
//
En enkel metod för att läsa tre RC kanaler med hjälp av pin ändra avbryter
//
Se relaterade inlägg-
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
//

inkluderar pinchangeint biblioteket - se länkarna i avsnittet närliggande information ovan för Detaljer
#include < PinChangeInt.h >

Tilldela din kanal i pins
#define THROTTLE_IN_PIN 5
#define STEERING_IN_PIN 6
#define AUX_IN_PIN 7

Tilldela din kanal ut pins
#define THROTTLE_OUT_PIN 8
#define STEERING_OUT_PIN 9
#define AUX_OUT_PIN 10

Tilldela servo index
#define SERVO_THROTTLE 0
#define SERVO_STEERING 1
#define 2
#define SERVO_FRAME_SPACE 3

Dessa bitflaggor som anges i bUpdateFlagsShared att ange vilka
kanaler har nya signaler
#define THROTTLE_FLAG 1
#define STEERING_FLAG 2
#define AUX_FLAG 4

innehar uppdatering flaggorna ovan definierade
flyktiga uint8_t bUpdateFlagsShared;

delade variabler uppdateras av ISR och läsa av loop.
I slinga vi omedelbart ta lokala kopior så att ISR kan hålla ägandet av den
delade de. Att få tillgång till dessa i slinga vi först inaktivera avbrott med noInterrupts
Vi tar en kopia att använda i loop och turn avbrott igen så snabbt som möjligt
Detta säkerställer att vi alltid ska kunna ta emot nya signaler
flyktiga uint16_t unThrottleInShared;
flyktiga uint16_t unSteeringInShared;
flyktiga uint16_t unAuxInShared;

Dessa används för att registrera stigande kanten av en puls i de calcInput funktionerna
De behöver inte vara flyktiga som de används bara i ISR. Om vi ville
för att hänvisa till dessa i loop och ISR skulle då de behöva förklaras flyktiga
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");

koppla servo objekt, dessa kommer att generera rätt
pulser för att köra elektroniska hastighetsregulatorer, servon eller andra enheter
utformad för att samverka direkt med RC mottagare
CRCArduinoFastServos::attach(SERVO_THROTTLE,THROTTLE_OUT_PIN);
CRCArduinoFastServos::attach(SERVO_STEERING,STEERING_OUT_PIN);
CRCArduinoFastServos::attach(SERVO_AUX,AUX_OUT_PIN);

låter som en standard frekvens på 50 Hz genom att ange en ram utrymme av 10 * 2000 = 3 servon + 7 gånger 2000
CRCArduinoFastServos::setFrameSpaceA(SERVO_FRAME_SPACE,7*2000);
CRCArduinoFastServos::begin();

med hjälp av PinChangeInt biblioteket, bifoga avbrotten används för att läsa kanalerna
PCintPort::attachInterrupt (THROTTLE_IN_PIN, calcThrottle, förändring);
PCintPort::attachInterrupt (STEERING_IN_PIN, calcSteering, förändring);
PCintPort::attachInterrupt (AUX_IN_PIN, calcAux, förändring);
}

void loop()
{
skapa lokala variabler för att lagra lokala kopior av kanal ingångarna
Detta förklaras som statiska så att deras värden bevaras mellan samtal till ögla.
statisk uint16_t unThrottleIn;
statisk uint16_t unSteeringIn;
statisk uint16_t unAuxIn;
lokal kopia av uppdatering flaggor
statisk uint8_t bUpdateFlags;

Kolla delade uppdatering flaggor för att se om några kanaler har en ny signal
IF(bUpdateFlagsShared)
{
noInterrupts(); Inaktivera avbrott snabbt medan vi vidta lokala kopior av de delade variablerna

ta en lokal kopia av vilka kanaler har uppdaterats så att vi kan använda detta i resten av loopen
bUpdateFlags = bUpdateFlagsShared;

i aktuell kod fylls gemensamma värden alltid
så vi kunde kopiera dem utan provning flaggor
men i framtiden kan detta förändras, så kan
Kopiera endast när flaggorna berättar vi kan.
IF(bUpdateFlags & THROTTLE_FLAG)
{
unThrottleIn = unThrottleInShared;
}
IF(bUpdateFlags & STEERING_FLAG)
{
unSteeringIn = unSteeringInShared;
}
IF(bUpdateFlags & AUX_FLAG)
{
unAuxIn = unAuxInShared;
}

Rensa delade kopian av uppdaterad flaggor som vi redan har tagit uppdateringarna
Vi har fortfarande en lokal kopia om vi behöver använda det i bUpdateFlags
bUpdateFlagsShared = 0;

interrupts(); Vi har lokala kopior av insatsvaror, så nu kan vi vända avbryter tillbaka på
så snart som avbryter är tillbaka på, kan vi inte längre använda delade kopiorna, avbrottet
Service rutiner äger dessa och kan uppdatera dem när som helst. Under uppdateringen, den
delade kopior kan innehålla skräppost. Lyckligtvis har vi vår lokala kopior att arbeta med :-)
}

göra någon bearbetning härifrån och framåt
Använd endast den lokala värden unAuxIn, unThrottleIn och unSteeringIn, den delade
variablerna unAuxInShared, unThrottleInShared, unSteeringInShared alltid ägs av
de avbrott rutinerna och bör inte användas i loop

följande kod ger enkel passera genom detta är ett bra första test
Arduinoen passerar genom receiver input som om Arduino inte är där.
Detta bör användas för att bekräfta den krets och makt
innan du försöker någon anpassad bearbetning i ett projekt.

Vi kontrollerar för att se om kanalvärdet har ändrats, anges detta
av flaggor. För den enkla passet genom vi egentligen inte behöver detta kontrollera,
men för ett mer komplexa projekt där en ny signal kräver betydande bearbetning
Detta tillåter oss att bara beräkna nya värden när vi har nya ingångar, snarare än
på varje cykel.
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;
}

enkla avbrottstjänstens rutin
void calcThrottle()
{
IF(PCintPort::pinState)
{
unThrottleInStart = TCNT1;
}
annat
{
unThrottleInShared = (TCNT1 - unThrottleInStart) >> 1;
bUpdateFlagsShared | = THROTTLE_FLAG;
}
}

void calcSteering()
{
IF(PCintPort::pinState)
{
unSteeringInStart = TCNT1;
}
annat
{
unSteeringInShared = (TCNT1 - unSteeringInStart) >> 1;

bUpdateFlagsShared | = STEERING_FLAG;
}
}

void calcAux()
{
IF(PCintPort::pinState)
{
unAuxInStart = TCNT1;
}
annat
{
unAuxInShared = (TCNT1 - unAuxInStart) >> 1;
bUpdateFlagsShared | = AUX_FLAG; }
}