Arduino RC-vliegtuig | 100% doe-het-zelf

In deze tutorial laat ik je zien hoe ik een op Arduino gebaseerd RC-vliegtuig bouw, en ook laat ik je zien hoe je het bestuurt met behulp van de op maat gemaakte Arduino-zender die ik in een van mijn vorige video's heb gebouwd.

Je kunt de volgende video bekijken of de schriftelijke tutorial hieronder lezen.

Overzicht

Het vliegtuig is dus volledig gemaakt van piepschuim. Voor het maken van de vormen heb ik mijn Arduino CNC-schuimsnijmachine gebruikt waarvan ik je in een vorige video al liet zien hoe ik het bouwde. Hoewel ik een CNC-machine gebruik om dit Arduino RC-vliegtuig te bouwen, kan ik nog steeds zeggen dat het 100% DIY is, omdat de CNC-machine ook een DIY-build is.

Bovendien is de besturing van het vliegtuig ook 100% DIY, gebaseerd op Arduino en de NRF24L01 module voor de radiocommunicatie.

Met de rechter joystick van de zender kunnen we de rolroeren en de lift van het vliegtuig bedienen, en met de linker joystick kunnen we het roer en de gashendel bedienen.

Daarnaast kunnen we met behulp van de rechter potentiometer het reactievermogen van de bedieningselementen aanpassen, of de hoeveelheid servo-uitslag verminderen, en met de linker joystick kunnen we het roer sub-trim of de neutrale positie van de servo-arm aanpassen.

Oh, en ik was de vermelding bijna vergeten, het belangrijkste kenmerk van dit Arduino RC-vliegtuig is vliegen, dus ja, het kan vliegen.

Het RC-vliegtuig ontwerpen – 3D-model

Ik begon met het ontwerpen van het vliegtuig met behulp van een 3D-modelleringssoftware, Fusion 360 in dit geval. Ik heb het ontwerp gemaakt door naar enkele commerciële RC-vliegtuigen te kijken en enkele basisrichtlijnen of vuistregels voor modelvliegtuigparameters te volgen.

Het uitgangspunt is de spanwijdte en ik heb gekozen voor 80cm. Van daaruit krijgen we de romplengte, die over het algemeen 75% van de spanwijdte is. Wat betreft het vleugelprofiel, of de vleugeldoorsnede, koos ik de CLARK Y Airfoil, een populaire keuze voor RC-vliegtuigen.

Ik heb de vorm van het vleugelprofiel gedownload van airfoiltools.com als .SVG-bestand en vervolgens geïmporteerd in Fusion 360. Ik heb de grootte op de juiste manier aangepast, zodat het vleugelakkoord, of de lengte van de vleugel in stroomrichting ongeveer 1/5e is van de spanwijdte.

Ook de horizontale en verticale stabilisator zijn gedimensioneerd volgens die basisrichtlijnen. Hier zijn enkele basisparameters voor het ontwerpen van RC-modelvliegtuigen:

De romp van het vliegtuig bestaat uit twee zijkanten van 10 mm en een kern van 50 mm die hol is om plaats te bieden aan de elektronica.

U kunt het 3D-model downloaden via de bovenstaande links. Er zijn twee versies van het vliegtuig. De versie 1 is degene die hier op de afbeeldingen wordt getoond, en versie twee heeft een iets kleinere neus en de motor kan meer naar voren worden geplaatst om de luchtstroom te verbeteren.

G-codes genereren voor mijn DIY CNC-schuimsnijder

Omdat het werkgebied van mijn Arduino CNC-schuimsnijmachine beperkt is tot 45 cm en de romp 60 cm lang is, moest ik de romp uit twee delen maken.

Dus ik sneed de romp op 34 cm van het voorste punt af en maakte een nieuwe schets waarin ik de vorm projecteerde en een punt ernaast toevoegde. Vervolgens kan ik op het tabblad fabricage van Fusion 360 de G-code genereren voor het snijden van de vormen.

Hier heb ik eerst een nieuwe opstelling gemaakt waarbij ik de schets als model selecteerde, het punt selecteerde dat ik eerder als oorsprong voor de opstelling had toegevoegd en de X- en Y-as op de juiste manier aanpaste.

Toen koos ik de 2D-contourbewerking en selecteerde of genereerde een nieuw gereedschap met een diameter van 3 mm, want dat is ongeveer de grootte van de sneden die de hete draad maakt wanneer deze door het piepschuim gaat. Hier kunnen we ook de snijtoevoer instellen die afhankelijk is van de hete draad zelf en de hardheid van het piepschuim. Ik heb hem ingesteld op 150 mm/m.

Vervolgens kunnen we in de geometriekraan de contour of de vorm selecteren die moet worden gesneden. Wat betreft de hoogten, ik heb ze allemaal op 1 mm ingesteld, omdat er geen beweging op de Z-as is op mijn schuimsnijmachine. Ten slotte heb ik in de koppelingskraan de invoerpositie geselecteerd als de rand nabij het oorsprongspunt.

Hiermee wordt het toolpad gegenereerd en kunnen we deze bekijken door op de knop Simulatie te klikken. Het toolpad moet een single-pass met gesloten lus zijn, en als dat het geval is, kunnen we eindelijk de G-code genereren. Daarvoor kunnen we naar Post Processes gaan, de GRBL-firmware selecteren, de outputmap selecteren, het bestand een naam geven en op de post-knop klikken.

Dan kunnen we het bestand opslaan, en we kunnen de G-code zien in de WordPad-editor of iets dergelijks.

Dus zodra we het G-code-bestand hebben, kunnen we het in de universele G-code-zender laden en de G-code naar de CNC-machine sturen om de vorm te maken.

We kunnen opmerken dat het proces dat ik je zojuist heb laten zien waarschijnlijk niet de beste of helemaal niet professioneel is, maar toch doet het zijn werk om de G-codes te laten werken met mijn DIY CNC-schuimsnijmachine. Natuurlijk kun je voor meer informatie over deze DIY CNC-machine mijn specifieke tutorial ervoor bekijken, de link staat in de beschrijving van de video.

U kunt de G-code-bestanden hier downloaden:

Zoals ik al zei, gebruikte ik voor de zijkanten 1 cm tick piepschuim en voor het midden gebruikte ik 5 cm tick piepschuim.

Wat betreft de vleugel, ik heb 10 cm tick-piepschuim gebruikt, dat ik ongeveer 30 cm breed heb gesneden, omdat dat de maximale spanwijdte is die mijn hetedraadmachine kan snijden. Ik heb twee vleugelprofielen in een enkel G-codebestand geplaatst en ik heb er een paar gesneden.

Om de spanwijdte van 80 cm te krijgen, lijm ik 3 stukken van 27 cm, en om ze recht te krijgen, knip ik de uiteinden van de stukken handmatig af zodat ze loodrecht staan.

Het RC-vliegtuig in elkaar zetten

Dus hier zijn alle stukjes piepschuim die ik met een CNC-machine heb gesneden. Drie stukken voor de voorkant, drie stukken voor de achterkant en drie stukken voor de vleugel. Nu kan ik ze in elkaar zetten.

Ik begin met het voorste gedeelte. Ik gebruik een lijmpistool om de stukken aan elkaar te lijmen. De hete lijm smolt een beetje van het piepschuim, maar toch kon ik ze met deze methode lijmen.

Een andere goede manier om piepschuim te lijmen is met 5 minuten epoxy. Voordat ik de andere kant ga lijmen, zal ik de houder voor de motor maken. Voor dat doel gebruik ik een 30 mm breed aluminium profiel dat vrij licht van gewicht is. Ik heb het profiel op ongeveer 18 cm gesneden, de gaten voor de montage van de motor gemarkeerd en ze geboord met een boor van 3 mm. Daarna heb ik het profiel 90 graden gebogen. Ik heb de motor aan de houder bevestigd met behulp van enkele M3-bouten.

Met behulp van deze montage heb ik een gat gemaakt door het voorste deel van het piepschuim. Vervolgens heb ik met een mes het gat vergroot tot een diameter van 30 mm, hetzelfde als de motordiameter.

Vervolgens heb ik aan de andere kant van de motorhouder 4 gaten gemaakt die dienen om de houder vast te zetten en tevens voor het bevestigen van het landingsgestel. Ik markeerde de locatie van deze gaten op de romp en met behulp van een boor van 4 mm maakte ik handmatig gaten door het piepschuim. Ik heb nog een aluminium stuk gemaakt van ongeveer 7 cm lang met dezelfde gaten, en nu kan ik het gebruiken om de motorhouder vast te zetten.

Met behulp van M4-bouten kunnen we de motorhouder eenvoudig op zijn plaats bevestigen zonder het piepschuim te beschadigen. Dat zal ik echter later doen, dus heb ik ze verwijderd en ben ik verder gegaan met het lijmen van de andere kant. Met dezelfde methode heb ik ook de achterstukken gelijmd.

De volgende stap is het huwelijk, of het verbinden van het voorste en het achterste deel van de romp. Om de verbinding sterker te maken, zal ik er eenvoudige barbecuestokjes tussen doen.

Ik zou zelfs willen voorstellen om wat grotere stokken te gebruiken, want als het vliegtuig neerstort, kan het hier gemakkelijk breken. Ik heb een behoorlijke hoeveelheid hete lijm aan de verbindingsplaats toegevoegd en ze samengeperst. Dus hier is hij dan, de romp is klaar en ik vind hem er best gaaf uitzien.

Vervolgens snij ik met een mes twee stukken piepschuim van 10 mm, die de horizontale en verticale stabilisatoren zullen zijn. Ik heb de randen afgeschuind zodat ze er beter uitzien en ook een beetje aerodynamischer zijn. De stabilisatoren worden direct aan de achterkant van de romp gelijmd, maar voordat ik dat doe, maak ik eerst hun controller-oppervlakken.

Voor dat doel heb ik ongeveer 1/3 van hun lengte gesneden, en dat zal hun stuuroppervlak zijn of het hoogteroer voor de horizontale stabilisator en het roer voor de verticale stabilisator. Om de stuurvlakken op de stabilisatoren te kunnen scharnieren, moest ik hun contactvlak afschuinen. Nogmaals, ik deed dat met een mes, en we hebben eigenlijk een vrij scherp mes nodig om deze sneden schoon te krijgen.

Ik ging verder met het wat aerodynamischer maken van de stabilisatoren. Voor dat doel heb ik schuurpapier gebruikt en hun voorranden afgerond. Ik heb ook de achterranden een beetje geschuurd.

Omdat het piepschuim behoorlijk kwetsbaar is, ga ik het hele gebied van de stabilisatoren en hun bedieningsoppervlakken inpakken met een eenvoudige verpakkingstape. Dit zal niet alleen de onderdelen sterker maken, maar ook de aerodynamica verhogen, omdat de tape veel gladder is dan het piepschuim zelf.

Na het wikkelen heb ik het onderste deel van het roer op 45 graden gesneden, om ruimte te maken voor de lift om vrij te kunnen bewegen.

Nu kan ik er eindelijk het scharnier voor maken, en dat doe ik weer met de verpakkingstape. Dus ik heb de twee delen gewoon met de tape verbonden, en dat maakt een vrij sterk scharnier.

Ik herhaalde dit proces ook voor de horizontale stabilisator. Om het scharnier nog sterker te maken kunnen we ook aan de andere kant tape toevoegen. Met dezelfde tape heb ik de zijkanten omwikkeld en daarmee zijn de twee stabilisatoren klaar.

Ik ging verder met het lijmen van de horizontale stabilisator aan de romp met behulp van een hete lijm. Om de verticale stabilisator vast te zetten, heb ik eerst 3 barbecuestokken door de horizontale stabilisator en de romp gestoken en gelijmd. Daarna deed ik wat hete lijm op hen en het contactoppervlak en duwde de stabilisator stevig naar beneden.

Hiermee zijn we klaar met de stabilisatoren en kunnen we verder met het maken van de vleugel.

Dus, zoals ik al zei, de vleugel zal uit 3 stukken worden gemaakt vanwege het beperkte werkgebied van mijn DIY CNC-schuimsnijmachine. Nogmaals, ik gebruik barbecuestokken voor extra sterkte bij het lijmen van de stukken. Om ze precies in lijn te bevestigen, gebruik ik een rechte houten strip waarop ik de stukken kan schuiven.

Als je daarmee klaar bent, is de vleugel eigenlijk behoorlijk kwetsbaar omdat hij lang en tin is. Daarom zal ik het versterken door er een houten stok aan toe te voegen. Ik heb de stok op maat gesneden en de vleugel gemarkeerd waar ik een zak moet maken zodat ik de stok erin kan passen. Met behulp van het mes maakte ik langzaam en voorzichtig de zak. Ik heb er wat hete lijm aan toegevoegd en het op zijn plaats vastgezet zonder de vorm van het vleugelprofiel te veel te verstoren.

Nu is de vleugel veel sterker met de houten stok op zijn plaats. Hoewel het sterker is, zou het nog steeds gemakkelijk uit elkaar vallen als het de grond raakt, dus daarom zal ik het allemaal inpakken met de verpakkingstape zoals ik deed met de stabilisatoren. Ik begon de tape toe te voegen vanaf de achterkant of de achterrand van de vleugel, aan de voorkant of de voorrand.

Op deze manier zal de binnenkomende lucht van de voorkant niet de neiging hebben om de tape los te laten. Hoewel dit proces er vrij eenvoudig uitziet, kan het een beetje vervelend zijn als je geen vaste handen en voldoende geduld hebt. Ik denk dat de vleugel er perfect uitkwam. Nu is het veel sterker, aerodynamischer en ziet het er best goed uit.

Oké, de volgende stap is het maken van de stuurvlakken van de vleugels of de rolroeren. Ik ga ze 22 cm breed maken en ongeveer 1/4 van het vleugelkoord lang. Om vrij te kunnen bewegen heb ik er ongeveer een halve centimeter van afgesneden.

En natuurlijk wikkelde ik alle randen die waren blootgelegd met het snijden. Vervolgens heb ik het onderste deel van het rolroer onder 45 graden afgeschuind en op dezelfde manier als eerder getoond, kan ik het nu aan de vleugel scharnieren. Om op de romp te passen en de vleugel gemakkelijk aan de romp te kunnen bevestigen, moest ik nog een uitsparing in het midden van de vleugel maken.

Vervolgens is het tijd om de servomotoren te installeren voor de besturing van de rolroeren. Ik gebruik de 9g micro-servo's. Ik heb de locatie gemarkeerd waar ze zullen worden geplaatst en met behulp van het mes heb ik voorzichtig een opening in de vleugel gemaakt zodat de servo erin kan passen. Ondertussen heb ik de montagebeugels van de servo's verwijderd, zodat hun vorm eenvoudiger is. Ik heb wat lijm op de servo gedaan en in de opening gestoken.

Met behulp van het mes heb ik een kleine groef gemaakt van de servo naar het midden van de vleugel, zodat ik de bedrading van de servo's erin kan passen. Als laatste heb ik alles afgeplakt met een stukje tape. Ik herhaalde hetzelfde proces ook voor de andere kant.

Ik ging verder met het maken van de bedieningshoorns. Ik ga ze maken van het aluminium profiel dat ik eerder gebruikte voor het maken van de motorhouder. Ik teken de vorm met de hand om ongeveer overeen te komen met de hoogte van de servomotorhoorn en om over het scharnierpunt te hangen. Ik heb de vorm gesneden met een ijzerzaag.

Ik zal 2 mm staaldraad gebruiken als stuurstang, dus heb ik een opening in de hoorn gemaakt met een boor van 2,5 mm. Ik maakte een kleine groef in het rolroer en lijmde de hoorn op zijn plaats. Daarna heb ik gemeten hoe lang de bedieningsstang zou moeten zijn en heb deze met behulp van een tang uit 2 mm staaldraad gemaakt. We moeten er rekening mee houden dat bij het meten en plaatsen van de regelstaven de servomotoren in de neutrale positie moeten staan.

Dat kunnen we doen door hem handmatig in het midden van zijn bewegingsbereik te plaatsen, of door hem aan te sluiten op een servotester of dat te doen met een Arduino. Ik herhaalde het proces voor de andere kant, en daarmee is de vleugel nu helemaal klaar.

Vervolgens moet ik de servo's installeren voor het besturen van het roer en de lift. Ik gebruik hier ook dezelfde 9g-microservo's, en het proces om ze te installeren is eigenlijk vrijwel hetzelfde als ik zojuist heb uitgelegd. Eerst heb ik de locatie gemarkeerd, de opening gemaakt met een mes en de twee motoren op hun plaats gelijmd. Hier staan ​​ze naast elkaar, maar met hun uitgaande assen aan de andere kant.

Nogmaals, ik heb een kleine groef in de romp gemaakt om de bedrading van de servo's naar het elektronicacompartiment te leiden. Ik heb de servo's afgedekt met een stukje tape en openingen gemaakt voor de servohoorns. Op dezelfde manier als eerder getoond heb ik de bedieningshoorns gemaakt en op hun plaats gelijmd met een lijmpistool. Ten slotte heb ik de juiste bedieningsstang gemaakt en dienovereenkomstig geïnstalleerd.

Ok, nu ga ik twee 8 mm houten staven installeren die zullen dienen om de vleugel aan de romp te bevestigen. Ik heb de gaten handmatig gemaakt met een boor van 6 mm. De staven moeten aan beide zijden ongeveer 1 cm overhangen. Ik heb ze ook met wat hete lijm aan de romp vastgemaakt en hier is hoe ze echt werken.

We gebruiken elastiekjes om de vleugel aan de romp te bevestigen. Op die manier kan de vleugel gemakkelijk worden verwijderd en in geval van beknelling zullen de elastiekjes de impact op de vleugel aanzienlijk verminderen. Tegelijkertijd is de montage sterk genoeg.

Vervolgens ga ik het landingsgestel maken. Voor dat doel zal ik opnieuw het aluminium profiel en de wielen van piepschuim gebruiken. Ik heb ze gemaakt met behulp van de CNC-machine zoals eerder getoond. Ik heb kleine groeven gemaakt in het aluminium profiel zodat ik het gemakkelijk kan buigen. Hier is hoe het landingsgestel eruit zou moeten zien.

Voor het bevestigen van de wielen aan het profiel gebruik ik M5 bouten en een aluminium buis met 6mm binnendiameter. De buis is aan de beugel bevestigd met behulp van de M5-bout en -moer, en aan de zijkanten heb ik M5-ringen toegevoegd zodat het wiel vrij rond de buis kan draaien. Met dezelfde methode maakte ik het wiel voor de achterkant van het vliegtuig.

Oké, dus nu zijn alle componenten klaar en voordat ik ze assembleer, laten we eens kijken naar de elektronica van dit project.

Arduino RC-vliegtuigelektronica - schakelschema

Dus, zoals ik al zei, dit RC-vliegtuig is volledig gebaseerd op de Arduino, zowel de zender als de ontvanger zijn op maat gemaakte builds op basis van het Arduino Pro Mini-bord.

Ik heb al gedetailleerde tutorials over hoe te bouwen en hoe de zender en de ontvanger werken, dus je kunt ze bekijken voor meer details. Hier zal ik het schakelschema en het werkingsprincipe van dit Arduino RC-vliegtuig uitleggen en hoe alles moet worden aangesloten.

U kunt de componenten die nodig zijn voor dit project verkrijgen via de onderstaande links:

• NRF24L01 + PA + LNA …………..…..…….
• Arduino Pro Mini………………..……….…..
• Servomotor …………………………………
• Borstelloze motor ……………………..……
• ESC 30A …………………………….…………
• Li-Po-batterij …………………..………………

De radiocommunicatie is dus gebaseerd op de NRF24L01-modules. Hoewel het er misschien een beetje ingewikkeld uitziet, is deze DIY Arduino-zender eigenlijk vrij eenvoudig. Het heeft verschillende controllers, de joysticks, de potentiometers en enkele knoppen, en het stuurt constant hun gegevens naar de ontvanger. De ontvanger accepteert deze gegevens draadloos via de NRF24L01-module en geeft de juiste opdrachten aan de servo's en de borstelloze motor om het vliegtuig te besturen.

Het besturen van servo's en borstelloze motoren met Arduino is ook vrij eenvoudig, dus daarom is dit hele Arduino RC-vliegtuigconcept volgens mij niet zo moeilijk te begrijpen. De borstelloze motor die ik in dit project gebruik, heeft een rating van 1000KV en vereist 30A ESC. De ESC drijft de motor aan en levert ook stroom aan de Arduino en de servo's via de Battery Eliminator Circuit-functie die 5V uitvoert. En de stroom naar de ESC en de borstelloze motor komt van een 3S Li-Po-batterij.

Ik heb nog een functie aan dit vliegtuig toegevoegd, en dat is een eenvoudige LED die aangeeft of de batterij leeg is. Met behulp van een eenvoudige spanningsdeler verlagen we de 12V afkomstig van de Li-Po-batterij tot ongeveer 5V, zodat we ze kunnen lezen met de Arduino analoge ingang en zo weten wanneer de batterij onder de 11V zakt. De ontvanger heeft nog steeds verschillende vrije kanalen, dus we kunnen meer functies aan dit vliegtuig toevoegen als we willen, zoals stroboscooplichten, flappen, drop-mechanismen enzovoort.

De montage voltooien

Laten we desondanks nu de vergadering afmaken. Dus ik heb alles aangesloten zoals uitgelegd in het schakelschema. Op kanaal 1 zit het roer, kanaal 2 het hoogteroer, kanaal 3 en 4 de rolroeren en op kanaal 6 de LED. Ik heb de LED aan de ene kant gelijmd en de aan / uit-schakelaar aan de andere kant.

We kunnen hier zien hoe het landingsgestel aan het vliegtuig wordt bevestigd met behulp van de twee bouten op de motorhouder. In een paar woorden, ik heb eenvoudig de motor met de houder uit deze bovenste opening geplaatst, op zijn plaats vastgeschroefd zoals eerder getoond, en ook het landingsgestel bevestigd. Bij het plaatsen van de houder heb ik ook wat elastiekjes toegevoegd zodat ze de batterij op zijn plaats kunnen houden.

Dus toen ik de batterij eenmaal op de ESC had aangesloten, heb ik alles erin geperst. Ten slotte kan ik met behulp van de verlengkabels de vleugelrolroeren gemakkelijk op de ontvanger aansluiten en vervolgens de vleugel aan de romp bevestigen.

Aan de voorkant heb ik de propeller aan de motor bevestigd en nu moet ik het zwaartepunt of het zwaartepunt van het vliegtuig controleren.

Het zwaartepunt is waarschijnlijk de belangrijkste factor of het vliegtuig goed of helemaal niet zal vliegen.

Het vliegtuig was aanvankelijk zwaar van de staart, dus ik verplaatste de batterij naar voren en voegde wat gewicht toe (enkele bouten en moeren) en het werd gebalanceerd.

Dat is het, ons op Arduino gebaseerde RC-vliegtuig is nu klaar en we kunnen naar buiten om het uit te proberen.

Het Arduino RC-vliegtuig testen

Nou, de eerste poging of de eerste vlucht was niet zo cool. Vooral na het zien van het resultaat van de verliefdheid.

Mijn conclusie hier was dat het vliegtuig nog steeds staartzwaar was en het voelde alsof de motor niet genoeg vermogen had. Omdat ik geen andere motor of propeller had om te proberen, heb ik de neus van het vliegtuig iets kleiner gemaakt, de motor meer naar voren verplaatst voor een betere luchtstroom en ook de randen aan de voorkant afgerond. Wat de structuur betreft, heb ik deze versterkt met enkele houten stokken en aluminium profielen die ik aan de binnenkant van de romp heb gelijmd.

Aan de onderkant van het elektronicacompartiment heb ik twee gaten gemaakt, een om de lucht te laten ontsnappen die uit de opening aan de voorkant komt, en de andere om de NRF24L01-antenne naar buiten te krijgen voor een bereik van de slagman.

Oké, hier is poging nummer twee. Nogmaals, bijna hetzelfde, hoewel het voelde alsof het nu een betere luchtstroom of kracht had.

De romp brak weer, wat aangeeft dat dit piepschuim vrij zwak is voor dit doel. Ik heb een nieuwe romp gemaakt en deze keer heb ik een klein beetje ducttape gebruikt om het te versterken.

Probeer nummer drie. Het zag er veelbelovend uit, maar het terrein dat ik heb om op te stijgen is eigenlijk helemaal niet goed. Het vliegtuig begon naar rechts te bewegen, raakte de rand van de weg en brak opnieuw.

Ik repareerde het en deze keer omwikkelde ik bijna de hele romp met duct- en verpakkingstape. Ik had dat veel eerder moeten doen, want dit gaf de romp de juiste sterkte en brak niet, zelfs niet na nog een paar keer verbrijzelen.

Het probleem was nu dat ik na verschillende crushes alle 4 de propellers brak die ik had, dus in deze poging gebruik ik een gelijmde propeller. Natuurlijk scheurde de propeller bij het opstijgen uit elkaar.

Ik probeerde het met een andere gelijmde propeller die was gemaakt van twee reeds kapotte propellers en deze keer had ik echt geluk en het vliegtuig steeg eindelijk goed op.

Nou, het geluk duurde niet lang, want de propeller brak opnieuw in de lucht.

Desalniettemin, aangezien dit mijn allereerste ervaring was met het vliegen met een RC-vliegtuig, denk ik dat ik dit project als succesvol kan beschouwen, aangezien ik erin geslaagd ben het concept te bewijzen van het maken van een volledig Arduino-gebaseerd systeem voor het besturen van RC-vliegtuigen.

Afgezien daarvan kunnen we uit de vlucht opmerken dat de bedieningselementen die van de zender komen eigenlijk te hard zijn. Dat komt omdat de joysticks helemaal niet goed zijn voor dit doel, ze hebben een klein bewegingsbereik en een slechte respons.

Om dit op te lossen, heb ik een functie aan het programma toegevoegd waarmee we het reactievermogen van de bedieningselementen kunnen regelen met behulp van de juiste potentiometer op de zender. Ook heb ik een functie toegevoegd waarmee we het roer kunnen trimmen met de linker potentiometer.

Arduino RC-vliegtuigcode

Laten we tot slot eens kijken naar de Arduino-code van dit op Arduino gebaseerde RC-vliegtuig en dit project afronden. De code is precies hetzelfde als uitgelegd in de vorige tutorial, voor het besturen van servo's en borstelloze motoren met behulp van de NRF24L01-transceivermodules.

Hier is de volledige code voor dit Arduino RC-vliegtuigproject:

/*
   Arduino RC Airplane
   == Receiver Code =
  by Dejan, www.HowToMechatronics.com
  Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <Servo.h>

#define led 9

RF24 radio(3, 2);   // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;

Servo throttle;  // create servo object to control the ESC
Servo rudderServo;
Servo elevatorServo;
Servo aileron1Servo;
Servo aileron2Servo;


int throttleValue, rudderValue, elevatorValue, aileron1Value, aileron2Value, travelAdjust;
// Max size of this struct is 32 bytes - NRF24L01 buffer limit
struct Data_Package {
  byte j1PotX;
  byte j1PotY;
  byte j1Button;
  byte j2PotX;
  byte j2PotY;
  byte j2Button;
  byte pot1;
  byte pot2;
  byte tSwitch1;
  byte tSwitch2;
  byte button1;
  byte button2;
  byte button3;
  byte button4;
};
Data_Package data; //Create a variable with the above structure
void setup() {
  Serial.begin(9600);
  radio.begin();
  radio.openReadingPipe(0, address);
  radio.setAutoAck(false);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_MAX);
  radio.startListening(); //  Set the module as receiver
  resetData();
  throttle.attach(10);
  rudderServo.attach(4);   // CH1
  elevatorServo.attach(5); // CH2
  aileron1Servo.attach(6); // CH3
  aileron2Servo.attach(7); // CH4
  pinMode(led, OUTPUT);    // CH6
}
void loop() {
  // Check whether we keep receving data, or we have a connection between the two modules
  currentTime = millis();
  if ( currentTime - lastReceiveTime > 1000 ) { // If current time is more then 1 second since we have recived the last data, that means we have lost connection
    resetData(); // If connection is lost, reset the data. It prevents unwanted behavior, for example if a drone jas a throttle up, if we lose connection it can keep flying away if we dont reset the function
  }
  // Check whether there is data to be received
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package)); // Read the whole data and store it into the 'data' structure
    lastReceiveTime = millis(); // At this moment we have received the data
  }

  // Controlling throttle - brushless motor with ESC
  throttleValue = constrain(data.j1PotY, 80, 255); // Joysticks stays in middle. So we only need values the upper values from 130 to 255
  throttleValue = map(throttleValue, 80, 255, 1000, 2000);
  throttle.writeMicroseconds(throttleValue);

  // Adjusting the servos responsiveness
  travelAdjust = map(data.pot2, 0, 255, 0, 25);  
  
  // Elevator control
  elevatorValue = map(data.j2PotY, 0, 255, (85 - travelAdjust), (35 + travelAdjust));
  elevatorServo.write(elevatorValue);
  
  // Ailerons control
  aileron1Value = map(data.j2PotX, 0, 255, (10 + travelAdjust), (80 - travelAdjust));
  aileron1Servo.write(aileron1Value);
  aileron2Servo.write(aileron1Value);

  // Rudder trimming function
  if (data.j1PotX > 127) {
    rudderValue = data.pot1 + (data.j1PotX - 127);
  }
  if (data.j1PotX < 127) {
    rudderValue = data.pot1 - (127 - data.j1PotX);
  }
  // Rudder control
  rudderValue = map(rudderValue, 0, 255, (10 + travelAdjust), (90 - travelAdjust));
  rudderServo.write(rudderValue);

  // Monitor the battery voltage
  int sensorValue = analogRead(A3);
  float voltage = sensorValue * (5.00 / 1023.00) * 3; // Convert the reading values from 5v to suitable 12V i
  // If voltage is below 11V turn on the LED
  if (voltage < 11) {
    digitalWrite(led, HIGH);
  }
  else {
    digitalWrite(led, LOW);
  }
}
void resetData() {
  // Reset the values when there is no radio connection - Set initial default values
  data.j1PotX = 127;
  data.j1PotY = 80; // Motors stops // the central point of the joystick is not starting point for the throttle, its at value of 80 instead of 127
  data.j2PotX = 127;
  data.j2PotY = 127;
  data.j1Button = 1;
  data.j2Button = 1;
  data.pot1 = 1;
  data.pot2 = 1;
  data.tSwitch1 = 1;
  data.tSwitch2 = 1;
  data.button1 = 1;
  data.button2 = 1;
  data.button3 = 1;
  data.button4 = 1;
}Code language: Arduino (arduino)

Beschrijving: I will just quickly explain the main functions of the code and for all other details you can check the previous tutorial. So, after receiving the data coming from the transmitter, we use the Joystick1 Y axis value for controlling the throttle of the airplane. We convert the values from 80 to 255 coming from the transmitter into values from 1000 to 2000 which are used for controlling the brushless motor.

For controlling the elevator, we use the Joystick2 Y axis value which we convert to values from 85 to 35. These values directly set the position of the servo motor in degrees. Right next to them we can note that we have the travelAdjust variables, which value depends on the position of the right potentiometer. We actually use that value to decrease the position or the movement of the servos although the joysticks will go to their maximum position.

The same principle is applied for controlling the ailerons and the rudder.  Additionally, we use the data from the left potentiometer to adjust the neutral point of the rudder.

Lastly, using the analogRead() function and some math we control the battery voltage indicator LED.

So that’s it. I would like to hear your thoughts about this project in the comments section below, especially from you who have experience with building and flying RC airplanes. For those who are beginners and thinking of getting into this, I would suggest to check the FliteTest YouTube channel because it’s an amazing resource for learning about this RC world. I will put a link to it in the description.

I hope you enjoyed this project and learned something new. Feel free to ask any question in the comments section below and don’t forget to check my Arduino Projects Collection.