Arduino-functiesreferentie. Programmeertalen

Historisch gezien bestaat de Arduino-software uit een geïntegreerde softwareomgeving (IDE) waarmee u de geschreven code naar de hardware kunt schrijven, compileren en uploaden. De ArduinoIDE-omgeving en de Wiring-taal zelf zijn voornamelijk gebaseerd op Processing en indirect op C/C++. In feite is de Arduino IDE een grote mengelmoes, niet voor de lol, maar voor het gemak.

Zelfs extern enArduinoIDE enDe verwerking is vergelijkbaar

Hardware "Hallo, wereld! - knipperende LED.
Wat de eerste kennismaking met Arduino op het grensvlak van software en hardware begint, is de knipperende LED.

Eerst moet je het minimumprogramma aanvullen. Voor Arduino (bijvoorbeeld UNO) sluiten we een LED aan op pin 12 en GND (de kleur van de LED zelf wordt gekozen vanuit persoonlijke voorkeur).

Installatie ongeldig() ( pinMode(12, OUTPUT); ) void loop() ( digitalWrite(12, HOOG); vertraging(100); digitalWrite(12, LAAG); vertraging(900); )
Voer Ctrl+C -> Ctrl+V uit, compileren, laden, besturen. We zien een lichtshow die niet langer dan een seconde duurt. Laten we uitzoeken waarom dit gebeurt.

We hebben er verschillende toegevoegd aan voorheen lege blokken uitdrukkingen . Ze werden tussen de accolades van de setup- en lusfuncties geplaatst.
Elke uitdrukking is een instructie voor de processor. Expressies binnen één blok worden na elkaar uitgevoerd, in strikte volgorde, zonder pauzes of wisselingen. Dat wil zeggen, als we het over één specifiek codeblok hebben, kan dit van boven naar beneden worden gelezen om te begrijpen wat er wordt gedaan.

Wat gebeurt er tussen{ } ?
Zoals je weet kunnen Arduino-pinnen zowel als uitvoer als invoer werken. Als we iets willen besturen, moeten we de controlepin naar de uitgangsstatus overbrengen. Dit wordt gedaan door expressie in de functie opstelling:
pinModus(12, UITVOER); In deze situatie wordt de uitdrukking uitgevoerd functie oproep . In pinMode wordt de door nummer gespecificeerde pin ingesteld op de opgegeven modus (INPUT of OUTPUT). Over welke pin en welke modus we het hebben, wordt tussen haakjes aangegeven, gescheiden door komma's. In ons geval willen we dat de 12e pin als uitvoer fungeert. OUTPUT betekent output, INPUT betekent input. Kwalificerende waarden zoals 12 en OUTPUT worden aangeroepen functie argumenten . Hoeveel argumenten een functie heeft, hangt af van de aard van de functie en de wil van de maker ervan. Functies kunnen helemaal geen argumenten hebben, zoals het geval is bij setup en loop.

Vervolgens gaan we verder met het lusblok, in de volgende volgorde:
-roep de ingebouwde functie digitalWrite aan. Het is ontworpen om een ​​logische nul (LAAG, 0 volt) of een logische nul (HOOG, 5 volt) toe te passen op een bepaalde pin. Er worden twee argumenten doorgegeven aan de digitalWrite-functie: het pinnummer en de logische waarde.
- Roep de vertragingsfunctie op. Dit is wederom een ​​ingebouwde functie die ervoor zorgt dat de processor een bepaalde tijd in slaap valt. Er is slechts één argument nodig: de tijd in milliseconden om te slapen. In ons geval is dit 100 ms. Zodra de 100 ms is verstreken, wordt de processor wakker en gaat onmiddellijk verder met de volgende expressie.
- roep de ingebouwde functie digitalWrite aan. Alleen deze keer is het tweede argument LAAG. Dat wil zeggen, we stellen een logische nul in op de 12e pin -> passen 0 volt toe -> schakelen de LED uit.
- het oproepen van de vertragingsfunctie. Deze keer “slapen” we iets langer – 900 ms.

Zodra de laatste functie is uitgevoerd, eindigt het lusblok en gebeurt alles opnieuw. In feite zijn de omstandigheden in het voorbeeld behoorlijk variabel, en je kunt spelen met de vertragingswaarden, meerdere LED's aansluiten en zoiets als een verkeerslicht of een politieflitser maken (het hangt allemaal af van de verbeeldingskracht en de wil van de maker).

In plaats van een conclusie, iets over netheid.
In feite betekenen alle spaties, regeleinden en tabtekens niet veel voor de compiler. Waar er een spatie is, kan er een regeleinde zijn en omgekeerd. In feite zijn 10 spaties op rij, 2 regeleinden en 5 extra spaties het equivalent van één spatie.

Met behulp van lege ruimte kun je een programma begrijpelijk en visueel maken, of juist onherkenbaar misvormen. Het voorbeeldprogramma kan bijvoorbeeld als volgt worden gewijzigd:
void setup() ( pinMode(12, OUTPUT); ) void loop () ( digitalWrite(12,HIGH); delay(100); digitalWrite(12,LOW); delay(900); )

Om te voorkomen dat iemand tijdens het lezen uit zijn ogen gaat bloeden, kun je een paar eenvoudige regels volgen:

1. Altijd aan het begin van een nieuw blok ertussen( En ) vergroot de inkeping. Meestal worden er 2 of 4 spaties gebruikt. Kies een van de waarden en houd je daar de hele tijd aan.

Lege lus() ( digitalWrite(12, HOOG); vertraging(100); digitalWrite(12, LAAG); vertraging(900); )
2. Net als in gewoon taalgebruik: zet een spatie na komma's.

digitalWrite(12, HOOG);
3. Plaats het begin-van-blok-teken (op een nieuwe regel op het huidige inspringingsniveau of aan het einde van het vorige. En het einde-van-blok-teken) op een aparte regel op het huidige inspringingsniveau:

void setup() ( pinMode(12, UITVOER); ) void setup() ( pinMode(12, OUTPUT); )
4. Gebruik lege regels om betekenisblokken van elkaar te scheiden:

void loop() ( digitalWrite(12, HOOG); vertraging(100); digitalWrite(12, LAAG); vertraging(900); digitalWrite(12, HOOG); vertraging(100); digitalWrite(12, LAAG); vertraging( 900);
5. Om uw kind met plezier te laten lezen, zijn er zogenaamde opmerkingen. Dit zijn constructies in de programmacode die volledig worden genegeerd door de compiler en alleen van belang zijn voor de persoon die de code leest. Opmerkingen kunnen uit meerdere regels of uit één regel bestaan:

/* dit is een commentaar van meerdere regels */ // dit is een commentaar van één regel

Hallo! Ik ben Alikin Alexander Sergejevitsj, een leraar aanvullend onderwijs, ik leid de clubs “Robotica” en “Radio Engineering” in het Centrum voor Jeugd en Jeugdtechnologie in Labinsk. Ik wil het graag hebben over een vereenvoudigde methode voor het programmeren van Arduino met behulp van het ArduBlock-programma.

Ik heb dit programma in het onderwijsproces geïntroduceerd en ben heel blij met het resultaat. Er is veel vraag naar bij kinderen, vooral bij het schrijven van eenvoudige programma's of bij het maken van een beginfase van complexe programma's. ArduBlock is een grafische programmeeromgeving, d.w.z. alle acties worden uitgevoerd met getekende afbeeldingen met ondertekende acties in het Russisch, wat het leren van het Arduino-platform aanzienlijk vereenvoudigt. Kinderen vanaf groep 2 kunnen dankzij dit programma gemakkelijk het werken met Arduino onder de knie krijgen.

Ja, iemand zou kunnen zeggen dat Scratch nog steeds bestaat en dat het ook een heel eenvoudige grafische omgeving is voor Arduino-programmering. Maar Scratch flasht de Arduino niet, maar bestuurt hem alleen via een USB-kabel. Arduino is computerafhankelijk en kan niet autonoom werken. Bij het maken van uw eigen projecten is autonomie het belangrijkste voor Arduino, vooral bij het maken van robotapparaten.

Zelfs bekende LEGO-robots, zoals NXT of EV3, zijn niet meer zo interessant voor onze studenten met de komst van het ArduBlock-programma in Arduino-programmeren. Arduino is ook veel goedkoper dan alle LEGO-bouwpakketten, en veel componenten kunnen eenvoudigweg uit oude huishoudelijke elektronica worden gehaald. Het ArduBlock-programma helpt niet alleen beginners, maar ook actieve gebruikers van het Arduino-platform.

Dus, wat is ArduBlock? Zoals ik al zei, is dit een grafische programmeeromgeving. Bijna volledig vertaald in het Russisch. Maar het hoogtepunt van ArduBlock is niet alleen dit, maar ook het feit dat het ArduBlock-programma dat we schreven, wordt omgezet in Arduino IDE-code. Dit programma is ingebouwd in de Arduino IDE-programmeeromgeving, dat wil zeggen dat het een plug-in is.

Hieronder ziet u een voorbeeld van een knipperende LED en een geconverteerd programma in Arduino IDE. Al het werken met het programma is heel eenvoudig en elke student kan het begrijpen.

Door met het programma te werken kun je niet alleen de Arduino programmeren, maar ook commando's bestuderen die we niet begrijpen in het tekstformaat van de Arduino IDE, maar als je te lui bent om standaardcommando's te schrijven, kun je deze snel gebruiken de muis om een ​​eenvoudig programma in ArduBlok te schetsen en het in de Arduino IDE te debuggen.

Om ArduBlok te installeren, moet u eerst de Arduino IDE downloaden en installeren vanaf de officiële Arduino-website en de instellingen begrijpen wanneer u met het Arduino UNO-bord werkt. Hoe je dat doet, staat beschreven op dezelfde website of op Amperka, of bekijk het op YouTube. Als dit allemaal is uitgezocht, moet je ArduBlok downloaden van de officiële website, hier. Ik raad niet aan om de nieuwste versies te downloaden, deze zijn erg ingewikkeld voor beginners, maar de versie van 12-07-2013 is de beste, dit bestand is daar het populairst.

Hernoem vervolgens het gedownloade bestand naar ardublock-all en in de map "documenten". We maken de volgende mappen: Arduino > tools > ArduBlockTool > tool en in de laatste gooien we het gedownloade en hernoemde bestand. ArduBlok werkt op alle besturingssystemen, zelfs op Linux, ik heb het persoonlijk getest op XP, Win7, Win8, alle voorbeelden zijn voor Win7. De installatie van het programma is voor alle systemen hetzelfde.

Nou, om het simpel te zeggen, ik heb een archief voorbereid op de 7z Mail-schijf, bij het uitpakken vind je 2 mappen. In de ene map staat al een werkend Arduino IDE-programma, en in de andere map moet de inhoud naar de map Documenten worden gestuurd.

Om in ArduBlok te kunnen werken, moet je de Arduino IDE uitvoeren. Vervolgens gaan we naar het tabblad Tools en daar vinden we het ArduBlok-item, klik erop - en hier is het, ons doel.

Laten we nu eens kijken naar de programma-interface. Zoals je al begrijpt, zitten er geen instellingen in, maar er zijn voldoende pictogrammen voor programmeren en elk ervan bevat een commando in Arduino IDE-tekstformaat. Nieuwe versies hebben nog meer pictogrammen, dus het begrijpen van de nieuwste versie van ArduBlok is moeilijk en sommige pictogrammen zijn niet in het Russisch vertaald.

In de sectie "Beheer" vinden we verschillende cycli.

In het gedeelte ‘Poorten’ kunnen we de waarden van de poorten beheren, evenals de geluidszender, servo of ultrasone nabijheidssensor die erop is aangesloten.

In het gedeelte ‘Getallen/Constanten’ kunnen we digitale waarden selecteren of een variabele maken, maar het is onwaarschijnlijk dat u het onderstaande zult gebruiken.

In de sectie “Operators” vinden we alle noodzakelijke vergelijkings- en berekeningsoperatoren.

In het gedeelte Hulpprogramma's worden voornamelijk getimede pictogrammen gebruikt.

"TinkerKit Bloks" is de sectie voor gekochte TinkerKit-sensoren. Zo'n set hebben wij natuurlijk niet, maar dit betekent niet dat de iconen niet geschikt zijn voor andere sets, integendeel, het is voor de jongens erg handig om iconen te gebruiken zoals het aanzetten van een LED of een knop. Deze tekens worden in bijna alle programma's gebruikt. Maar ze hebben een bijzonderheid: wanneer u ze selecteert, zijn er onjuiste pictogrammen die poorten aangeven, dus u moet ze verwijderen en het pictogram vervangen uit het gedeelte "getallen/constanten" bovenaan de lijst.

"DF Robot" - deze sectie wordt gebruikt als de daarin gespecificeerde sensoren beschikbaar zijn, ze worden soms gevonden. En ons voorbeeld van vandaag is daarop geen uitzondering: we hebben een “Verstelbare IR-schakelaar” en een “Lijnsensor”. De “lijnsensor” is anders dan die op de foto, aangezien deze van het bedrijf Amperka is. Hun acties zijn identiek, maar de Ampere-sensor is veel beter, omdat deze een gevoeligheidsregelaar heeft.

"Seedstudio Grove" - ​​Ik heb de sensoren in deze sectie nooit gebruikt, hoewel er alleen joysticks zijn. In nieuwe versies is deze sectie uitgebreid.

En het laatste deel is de “Linker Kit”. De daarin gepresenteerde sensoren ben ik niet tegengekomen.

Ik wil graag een voorbeeld laten zien van een programma over een robot die langs een strook beweegt. De robot is heel eenvoudig, zowel in elkaar te zetten als te kopen, maar eerst en vooral. Laten we beginnen met de aanschaf en montage ervan.

Hier is de set onderdelen zelf, alles is gekocht op de Amperka-website.

1. AMP-B001 Motorscherm (2 kanalen, 2 A) RUB 1.890
2. AMP-B017 Troyka-schild RUB 1.690
3. AMP-X053 Batterijcompartiment 3×2 AA 1 60 RUR
4. AMP-B018 Digitale lijnsensor RUB 2.580
5. ROB0049 MiniQ tweewielig platform RUB 1,1890
6. SEN0019 Infrarood obstakelsensor RUB 1.390
7. FIT0032 Houder voor infrarood obstakelsensor RUB 1,90
8. A000066 Arduino Uno 1 1150 RUR

Laten we eerst het platform op wielen monteren en de draden aan de motoren solderen.

Vervolgens zullen we rekken installeren om het Arduino UNO-bord te monteren, die zijn overgenomen van een oud moederbord of andere soortgelijke steunen.

Vervolgens bevestigen we het Arduino UNO-bord aan deze racks, maar we kunnen geen enkele bout vastdraaien: de connectoren zitten in de weg. Je kunt ze natuurlijk losmaken, maar dit is naar eigen goeddunken.

Vervolgens bevestigen we de infrarood obstakelsensor op de speciale houder. Let op: de gevoeligheidsregelaar bevindt zich bovenaan, dit is voor het gemak van het afstellen.

Nu installeren we digitale lijnsensoren, hier moet je een paar bouten en 4 moeren voor zoeken. We installeren twee moeren tussen het platform zelf en de lijnsensor, en bevestigen de sensoren met de rest.

Vervolgens installeren we Motor Shield, of anders kun je het de motordriver noemen. Let in ons geval op de springer. We gaan geen aparte voeding voor de motoren gebruiken, daarom wordt deze in deze positie geïnstalleerd. Het onderste deel is afgedicht met isolatietape om onbedoelde kortsluiting van de Arduino UNO USB-connector te voorkomen, voor het geval dat.

We installeren Troyka Shield bovenop het Motor Shield. Het is noodzakelijk voor het gemak van het aansluiten van sensoren. Alle sensoren die we gebruiken zijn digitaal, dus de lijnsensoren zijn aangesloten op poort 8 en 9, zoals ze ook wel pinnen worden genoemd, en de infrarood obstakelsensor is aangesloten op poort 12. Houd er rekening mee dat u de poorten 4, 5, 6 en 7 niet kunt gebruiken, omdat deze door Motor Shield worden gebruikt om motoren te besturen. Ik heb deze poorten zelfs speciaal met een rode stift overschilderd, zodat de leerlingen het konden uitzoeken.

Als je het al gemerkt hebt, heb ik voor de zekerheid een zwarte bus toegevoegd, zodat het batterijcompartiment dat we hebben geïnstalleerd niet naar buiten zou vliegen. En ten slotte zetten we de hele structuur vast met een gewone elastische band.

Er zijn 2 soortenn. Eerste aansluiting van draden op Troyka Shield. Het is ook mogelijk om de stekker te solderen en deze op het Arduino UNO-bord zelf aan te sluiten.

Onze robot is er klaar voor. Voordat u begint met programmeren, moet u leren hoe alles werkt, namelijk:
- Motoren:
Poorten 4 en 5 worden gebruikt om één motor te besturen, en 6 en 7 een andere;
We regelen de rotatiesnelheid van de motoren met behulp van PWM op poort 5 en 6;
Vooruit of achteruit door signalen naar poorten 4 en 7 te sturen.
- Sensoren:
We zijn allemaal digitaal, dus ze geven logische signalen in de vorm van 1 of 0;
En om ze aan te passen, hebben ze speciale regelaars en met behulp van een geschikte schroevendraaier kunnen ze worden gekalibreerd.

Details zijn te vinden bij Amperke. Waarom hier? Omdat er veel informatie te vinden is over het werken met Arduino.

Nou ja, we hebben waarschijnlijk alles oppervlakkig bekeken, bestudeerd en natuurlijk de robot in elkaar gezet. Nu moet het geprogrammeerd worden, hier is het - het langverwachte programma!

En het programma geconverteerd naar Arduino IDE:

Setup ongeldig maken() ( pinMode(8 , INPUT); pinMode(12 , INPUT); pinMode(9 , INPUT); pinMode(4 , OUTPUT); pinMode(7 , OUTPUT); pinMode(5, OUTPUT); pinMode(6 , OUTPUT); ) void loop() ( if (digitalRead(12)) ( if (digitalRead(8)) ( if (digitalRead(9)) ( digitalWrite(4, HOOG); analogWrite(5, 255); analogWrite( 6, 255); digitalWrite(7, HOOG); else ( digitalWrite(4, HOOG); analogWrite(5, 255); analogWrite(6, 50); digitalWrite(7, LAAG); ) ) else ( if (digitalRead) (9)) ( digitalWrite(4, LAAG); analogWrite(5, 50); analogWrite(6, 255); digitalWrite(7, HOOG); ) else ( digitalWrite(4, HOOG); analogWrite(5, 255); analogWrite(6, 255); digitalWrite(7, HOOG); anders ( digitalWrite(4, HOOG); analogWrite(5, 0); analogWrite(6, 0); digitalWrite(7, HOOG); ) )

Concluderend wil ik zeggen dat dit programma gewoon een geschenk uit de hemel is voor het onderwijs; zelfs voor zelfstudie zal het je helpen Arduino IDE-commando's te leren. Het belangrijkste hoogtepunt is dat er meer dan 50 installatiepictogrammen zijn, het begint te "glitchen". Ja, dit is inderdaad het hoogtepunt, aangezien programmeren alleen op ArduBlok je niet leert programmeren in de Arduino IDE. De zogenaamde "glitch" geeft je de mogelijkheid om na te denken en commando's te onthouden voor het nauwkeurig debuggen van programma's.

Ik wens je succes.

Arduino is erg populair onder alle designliefhebbers. Ook degenen die er nog nooit van hebben gehoord, moeten er kennis mee maken.

Wat is Arduino?

Hoe kun je Arduino kort omschrijven? De beste woorden zouden zijn: Arduino is een hulpmiddel dat kan worden gebruikt om verschillende elektronische apparaten te maken. In wezen is dit een echt hardwarecomputerplatform voor algemene doeleinden. Het kan zowel worden gebruikt voor het construeren van eenvoudige circuits als voor het implementeren van vrij complexe projecten.

De ontwerper is gebaseerd op de hardware, een invoer-uitvoerbord. Voor het programmeren van het bord worden talen gebruikt die gebaseerd zijn op C/C++. Ze worden respectievelijk Processing/Wiring genoemd. Van groep C hebben ze extreme eenvoud geërfd, waardoor ze door iedereen heel snel onder de knie kunnen worden, en het toepassen van kennis in de praktijk geen groot probleem is. Om het werkgemak te begrijpen, wordt er vaak gezegd dat Arduino voor beginnende wizard-ontwerpers is. Zelfs kinderen kunnen Arduino-borden begrijpen.

Wat kun je erop verzamelen?

De toepassingen van Arduino zijn behoorlijk divers; het kan zowel voor de eenvoudigste voorbeelden worden gebruikt, die aan het einde van het artikel worden aanbevolen, als voor vrij complexe mechanismen, waaronder manipulatoren, robots of productiemachines. Sommige vakmensen slagen erin dergelijke systemen te gebruiken om tablets, telefoons, bewakings- en beveiligingssystemen voor thuis, slimme thuissystemen of gewoon computers te maken. Arduino-projecten voor beginners, waarmee zelfs mensen zonder ervaring aan de slag kunnen, staan ​​aan het einde van het artikel. Ze kunnen zelfs worden gebruikt om primitieve virtual reality-systemen te creëren. Allemaal dankzij de redelijk veelzijdige hardware en mogelijkheden die Arduino-programmering biedt.

Waar kan ik de componenten kopen?

Componenten gemaakt in Italië worden als origineel beschouwd. Maar de prijs van dergelijke kits is niet laag. Daarom maken een aantal bedrijven of zelfs individuen ambachtelijke methoden van Arduino-compatibele apparaten en componenten, die gekscherend productieklonen worden genoemd. Bij het kopen van dergelijke klonen kan niet met zekerheid worden gezegd dat ze zullen werken, maar de wens om geld te besparen eist zijn tol.

Componenten kunnen worden gekocht als onderdeel van kits of afzonderlijk. Er zijn zelfs kant-en-klare kits voor het assembleren van auto's, helikopters met verschillende soorten besturingen of schepen. Een set zoals hierboven afgebeeld, gemaakt in China, kost $ 49.

Meer over de uitrusting

Het Arduino-bord is een eenvoudige AVR-microcontroller, die is geflashed met een bootloader en over de minimaal vereiste USB-UART-poort beschikt. Er zijn nog andere belangrijke componenten, maar binnen de reikwijdte van dit artikel zou het beter zijn om alleen op deze twee componenten te focussen.

Ten eerste over de microcontroller, een mechanisme gebouwd op een enkel circuit waarin het ontwikkelde programma zich bevindt. Het programma kan worden beïnvloed door op knoppen te drukken, signalen te ontvangen van de componenten van de creatie (weerstanden, transistors, sensoren, enz.), enz. Bovendien kunnen de sensoren heel verschillend zijn in hun doel: verlichting, versnelling, temperatuur, afstand, druk, obstakels enz. Eenvoudige onderdelen kunnen worden gebruikt als weergaveapparaten, van LED's en tweeters tot complexe apparaten, zoals grafische displays. De kwaliteit die in aanmerking wordt genomen zijn motoren, kleppen, relais, servo's, elektromagneten en vele andere, het zou heel, heel lang duren om ze op te noemen. De MK werkt rechtstreeks met sommige van deze lijsten, met behulp van verbindingsdraden. Voor sommige mechanismen zijn adapters nodig. Maar als je eenmaal begint met ontwerpen, zal het moeilijk voor je zijn om jezelf los te rukken. Laten we het nu hebben over Arduino-programmering.

Meer informatie over het bordprogrammeringsproces

Een programma dat al klaar is om op een microcontroller te draaien, wordt firmware genoemd. Er kan één project of Arduino-projecten zijn, dus het is raadzaam om elke firmware in een aparte map op te slaan om het proces van het vinden van de benodigde bestanden te versnellen. Het wordt op het MK-kristal geflitst met behulp van gespecialiseerde apparaten: programmeurs. En hier heeft Arduino één voordeel: er is geen programmeur voor nodig. Alles is gedaan zodat het programmeren van Arduino voor beginners niet moeilijk is. De geschreven code kan via een USB-kabel in de MK worden geladen. Dit voordeel wordt niet bereikt door een vooraf gebouwde programmeur, maar door speciale firmware - een bootloader. De bootloader is een speciaal programma dat onmiddellijk na het verbinden start en luistert of er commando's zijn, of het kristal moet flashen, of er Arduino-projecten zijn of niet. Er zijn verschillende zeer aantrekkelijke voordelen aan het gebruik van een bootloader:

1. Met slechts één communicatiekanaal, wat geen extra tijdskosten met zich meebrengt. Voor Arduino-projecten hoef je dus niet veel verschillende draden aan te sluiten en er zal verwarring ontstaan ​​bij het gebruik ervan. Eén USB-kabel is voldoende voor een succesvolle werking.
2. Bescherming tegen kromme handen. Het is vrij eenvoudig om de microcontroller in een stenen staat te brengen met behulp van directe firmware; je hoeft niet hard te werken. Als je met een bootloader werkt, heb je geen toegang tot potentieel gevaarlijke instellingen (uiteraard met behulp van een ontwikkelprogramma, anders kan alles kapot gaan). Daarom is Arduino voor beginners niet alleen bedoeld vanuit het oogpunt dat het begrijpelijk en handig is, maar u kunt ook ongewenste financiële kosten vermijden die verband houden met de onervarenheid van de persoon die ermee werkt.

Projecten om van start te gaan

Als je een kit, een soldeerbout, hars en soldeer hebt aangeschaft, moet je niet meteen zeer complexe structuren boetseren. Natuurlijk kun je ze maken, maar de kans op succes in Arduino voor beginners is bij complexe projecten vrij laag. Om je vaardigheden te trainen en te verbeteren, kun je proberen een paar eenvoudigere ideeën te implementeren die je zullen helpen de interactie en werking van Arduino te begrijpen. Als eerste stappen in het werken met Arduino voor beginners kunnen wij u adviseren om het volgende te overwegen:

1. Maak er een die werkt dankzij Arduino.
2. Een aparte knop aansluiten op Arduino. In dit geval kunt u ervoor zorgen dat de knop de gloed van de LED vanaf punt nr. 1 kan aanpassen.
3. Potentiometer-aansluiting.
4. Servo-aandrijfbesturing.
5. Aansluiten en werken met een driekleurige LED.
6. Het piëzo-elektrische element aansluiten.
7. Een fotoresistor aansluiten.
8. Een bewegingssensor aansluiten en signalen geven over de werking ervan.
9. Een vochtigheids- of temperatuursensor aansluiten.

Projecten voor de toekomst

Het is onwaarschijnlijk dat u geïnteresseerd bent in Arduino om individuele LED's aan te sluiten. Hoogstwaarschijnlijk wordt u aangetrokken door de mogelijkheid om uw eigen auto of vliegende draaitafel te maken. Deze projecten zijn moeilijk te implementeren en vergen veel tijd en doorzettingsvermogen, maar eenmaal voltooid krijg je wat je wilt: waardevolle Arduino-ontwerpervaring voor beginners.

Arduino is in feite de ontwikkeling van unieke projecten voor alle gelegenheden. Zoals ik al schreef is Arduino een soort bordje met daarop een microcontroller, dat zonder problemen geprogrammeerd kan worden.

Het uiteindelijke doel van deze manipulaties is om een ​​eenvoudig beheer van velen te garanderen externe apparaten. Dit bord communiceert met de buitenwereld via vele add-ons:

• sensoren,
• LED's,
• motoren,
• Internet-netwerk
• enz.

Dit maakt het een redelijk universeel platform voor veel projecten van zeer verschillende niveaus. Momenteel zijn er nogal wat verschillende microcontrollers, waaronder Arduino vooral populair is, wat gepaard gaat met het actief plaatsen van de meest ongelooflijke projecten en ontwikkelingen op het netwerk.

Om één van de miljoenen ideeën eenvoudig te kunnen implementeren, kunt u eenvoudig gebruik maken van de meest actuele informatie die op veel sites onafhankelijk beschikbaar is. Hieronder ziet u een voorbeeld van de implementatie van een van deze ideeën: een kerstbel die kan worden bediend:

Hoe je dat kunt doen, gaan we in een van de volgende lessen bekijken.

In het geval dat u nog niet eens een beetje ervaring heeft met het werken met microcontrollers (programmeren en configureren), kunt u dankzij de functies eenvoudig zelf leren door relatief korte experimenten uit te voeren. Hieronder stel ik voor om enkele mogelijkheden van Arduino te analyseren, voorbeelden van waar deze unieke constructor het beste kan worden gebruikt.

Arduino-schetsen

Eigenlijk heet het programma voor een microcontroller van dit type schetsen. Elk dergelijk programma bestaat rechtstreeks uit twee hoofdfuncties.

Installatie

Setup() – er is in voorzien dat de gebruiker binnen deze functie alle belangrijke instellingen kan instellen.

Er wordt bijvoorbeeld bepaald welke pinnen vervolgens als output of input zullen werken, het bepalen van de verbinding van specifieke bibliotheken, zelfs het initialiseren van variabelen, dit alles wordt bepaald door het gebruik van deze functionaliteit.

De lancering wordt strikt één keer uitgevoerd tijdens de hele schets, wanneer het allereerste begin van de uitvoering van dit programma wordt genoteerd.

Lus

Loop() - is de hoofdfunctie die onmiddellijk na het starten wordt uitgevoerd (in dit geval wordt deze gebruikt instellen()).

In feite is dit het programma zelf; deze functie blijft oneindig actief totdat de gebruiker de stroom van het apparaat uitschakelt.

Voorbeelden van schetsen

U kunt enkele voorbeelden van schetsen overwegen die een leidraad zullen vormen voor de daaropvolgende bediening van de apparatuur. Ik zal proberen elk van de voorbeelden in de volgende materialen te implementeren. Vandaag zullen we het alleen hebben over de mogelijkheden.

Voorbeeld 1

Een van de interessante schetsen kan worden gebruikt om de werkelijke bedrijfstijd van de controller weer te geven, gevolgd door het aannemen van het “knipper”-commando. Het is bedoeld om de knipperprocedure van LED-elementen te initialiseren.

In feite is er niets bijzonder nuttigs in de schets, maar het omvat ook de mogelijkheid om willekeurig een bepaalde zinsnede "Gegevens ontvangen" uit te voeren; deze kan in de toekomst direct worden gebruikt voor het testen en analyseren van de vastgestelde regels voor de werking van een modulair systeem element.

Voorbeeld 2

Een speciaal aansluiten huidige waterniveausensor, regensensor. Om een ​​specifiek project te implementeren, moet u beschikken over:

De watersensor zelf,
- Arduino-controller,
- een set aansluitdraden,
- een computer met kabels en IDE-programma, bijbehorend ontwikkelbord.

Hierdoor worden dankzij de relatief eenvoudige opstelling van de microcontroller optimale omstandigheden voor de werking van de sensor gecreëerd.

Voorbeeld 3

De mogelijkheid tot implementatie karakteruitvoer, daaropvolgende installatie van lettertypen op de LCD5110, die de eenvoudigste en meest betrouwbare controle over de status van de apparatuur zelf zal bieden.

Lettertypen worden uitgevoerd en gewijzigd met behulp van Arduino-mogelijkheden. In dit geval moet u een kant-en-klare gegevensbibliotheek en broncode gebruiken.

Voorbeelden van het gebruik van Arduino

Als je naar de talloze voorbeelden van Arduino kijkt, kun je alleen maar verbaasd zijn over de creatieve aanpak van projectontwikkelaars en de buitengewone verbeeldingskracht. In feite kun je de meest ongelooflijke dingen maken, bijvoorbeeld hetzelfde muziekspeler met LED-set.

Een dergelijke ontwikkeling zal zeer gewaardeerd worden door muziekliefhebbers, waardoor ze niet alleen een originele soundtrack kunnen creëren, maar ze ook de kans geven om te genieten van een heldere, buitengewone kleurencombinatie.

Zelfs huisdieren, bijvoorbeeld katten, zullen de projecten kunnen evalueren. De reden zal zijn automatische kattenvoer, die bijvoorbeeld kan worden ontwikkeld op basis van een conventionele cd-speler, en niet alleen.

Een van de voordelen van deze apparatuur is de mogelijkheid om gedoseerd voedsel aan het dier te voeren, nu het niet nodig is om regelmatig de hoeveelheid voedsel in de kom te controleren. De openingstijd wordt aangepast, waarna de kat voedzaam voedsel krijgt, strikt volgens het vastgestelde schema, genietend van het originele idee van de eigenaar.

Als we het hebben over volledig ongebruikelijke projecten, kunnen we dit benadrukken automatische bloemapparatuur, dat nu informatie over zijn huidige status rechtstreeks naar Twitter kan verzenden. Dit alles wordt gedaan door gebruik te maken van de mogelijkheden van de Arduino-microcontroller, waarmee u gegevens rechtstreeks via een internetverbinding kunt overbrengen. Zoals u kunt zien, kunnen de voorbeelden heel verschillend zijn. Ik zal proberen er in de volgende artikelen aandacht aan te besteden.

Deze simulator werkt het beste in de Chrome-browser
Laten we Arduino eens nader bekijken.

Arduino is geen grote computer die op externe circuits kan worden aangesloten. Arduino Uno maakt gebruik van Atmega 328P
Dit is de grootste chip op het bord. Deze chip voert programma's uit die in zijn geheugen zijn opgeslagen. Je kunt het programma downloaden via usb met behulp van Arduino IDE. De USB-poort levert ook stroom aan de Arduino.

Er is een aparte stroomaansluiting. Het bord heeft twee pinnen met de aanduiding 5v en 3,3v, die nodig zijn om verschillende apparaten van stroom te voorzien. Ook vind je pinnen gemarkeerd met GND, dit zijn de aardingspinnen (aarde is 0V). Het Arduino-platform heeft ook 14 digitale pinnen, gelabeld met 0 tot 13, die verbinding maken met externe knooppunten en twee statussen hebben: hoog of laag (aan of uit). Deze contacten kunnen werken als uitgangen of als ingangen, d.w.z. ze kunnen bepaalde gegevens verzenden en externe apparaten besturen, of gegevens van apparaten ontvangen. De volgende pinnen op het bord hebben het label A0-A5. Dit zijn analoge ingangen die data van verschillende sensoren kunnen ontvangen. Dit is vooral handig als u een bepaald bereik moet meten, zoals de temperatuur. De analoge ingangen hebben extra functies die afzonderlijk kunnen worden ingeschakeld.

Hoe een ontwikkelbord te gebruiken.

Het breadboard is nodig om de onderdelen tijdelijk met elkaar te verbinden, controleer hoe het apparaat werkt, voordat je alles aan elkaar soldeert.
Alle volgende voorbeelden zijn op een breadboard gemonteerd, zodat u snel wijzigingen in het circuit kunt aanbrengen en onderdelen kunt hergebruiken zonder dat u zich hoeft te bekommeren om solderen.

Het breadboard heeft rijen gaten waarin je onderdelen en draden kunt steken. Sommige van deze gaten zijn elektrisch met elkaar verbonden.

De twee bovenste en onderste rijen zijn in rijen over het hele bord met elkaar verbonden. Deze rijen worden gebruikt om het circuit van stroom te voorzien. Het kan 5V of 3,3V zijn, maar hoe dan ook, het eerste dat u hoeft te doen is 5V en GND op het breadboard aansluiten, zoals weergegeven in de afbeelding. Soms zijn deze rijverbindingen in het midden van het bord verbroken. Als dat nodig is, kunt u ze aansluiten zoals weergegeven in de afbeelding.

Waarom is een weerstand nodig in een circuit? In dit geval beperkt het de stroom die door de LED gaat. Elke LED is ontworpen voor een bepaalde stroom, en als deze stroom hoger is, zal de LED uitvallen. Met behulp van de wet van Ohm kun je uitvinden welke waarde de weerstand moet hebben. Voor degenen die het niet weten of vergeten zijn: de wet van Ohm zegt dat er een lineair verband bestaat tussen stroom en spanning. Dat wil zeggen: hoe meer spanning we op de weerstand toepassen, hoe meer stroom er doorheen zal stromen.
V=I*R
Waar V- spanning over de weerstand
I- stroom door de weerstand
R- weerstand die gevonden moet worden.
Eerst moeten we de spanning over de weerstand bepalen. De meeste 3 mm of 5 mm LED's die u gebruikt, hebben een bedrijfsspanning van 3V. Dit betekent dat we 5-3 = 2V bij de weerstand moeten doven.

Vervolgens berekenen we de stroom die door de weerstand gaat.
De meeste 3 mm en 5 mm LED's gloeien op volledige helderheid bij 20 mA. Een stroom groter dan deze kan ze uitschakelen, terwijl een stroom van lagere intensiteit hun helderheid zal verminderen zonder enige schade aan te richten.

We willen de LED dus op het 5V-circuit aansluiten, zodat deze een stroom van 20 mA voert. Omdat alle onderdelen in één circuit zitten, heeft de weerstand ook een stroomsterkte van 20 mA.
Wij krijgen
2V = 20 mA *R
2V = 0,02A *R
R = 100 Ohm
100 Ohm is de minimale weerstand, het is beter om iets meer te gebruiken, omdat LED's enige variatie in eigenschappen hebben.
In dit voorbeeld wordt een weerstand van 220 ohm gebruikt. Alleen maar omdat de auteur er veel heeft: knipoog: .

Steek de LED in de gaten in het midden van het bord, zodat de lange kabel is aangesloten op een van de weerstandsdraden. Sluit het tweede uiteinde van de weerstand aan op 5V en sluit de tweede draad van de LED aan op GND. De LED moet oplichten.

Houd er rekening mee dat er een verschil zit in de manier waarop je de LED aansluit. De stroom vloeit van de langere terminal naar de kortere. In het diagram kun je je voorstellen dat de stroom vloeit in de richting waarin de driehoek is gericht. Probeer de LED ondersteboven te draaien en u zult zien dat deze niet oplicht.

Maar hoe je de weerstand aansluit, maakt helemaal niets uit. Je kunt hem omdraaien of proberen hem op een andere pin van de LED aan te sluiten, dit heeft geen invloed op de werking van het circuit. Het zal nog steeds de stroom door de LED beperken.

Anatomie van Arduino-schets.

Programma's voor Arduino worden sketch genoemd. Ze bestaan ​​uit twee hoofdfuncties. Functie opstelling en functie lus
Binnen deze functie stelt u alle basisinstellingen in. Welke pinnen zullen werken als invoer of uitvoer, welke bibliotheken moeten worden aangesloten, initialiseren variabelen. Functie Installatie() wordt slechts één keer uitgevoerd tijdens de schets, wanneer de programma-uitvoering start.
dit is de hoofdfunctie die daarna wordt uitgevoerd instellen(). In feite is het het programma zelf. Deze functie blijft voor onbepaalde tijd actief totdat u de stroom uitschakelt.

Arduino knipperende LED

In dit voorbeeld zullen we een LED-circuit aansluiten op een van de digitale pinnen van de Arduino en deze met een programma aan- en uitzetten, en je leert ook verschillende handige functies.

Deze functie wordt gebruikt bij instellen() onderdeel van het programma en dient om de pinnen te initialiseren die u als invoer gaat gebruiken (INVOER) of uitgang (OUTPUT). U kunt geen gegevens van de pin lezen of schrijven totdat u deze op respectievelijk instelt pinModus. Deze functie heeft twee argumenten: pinNummer is de pincode die u gaat gebruiken.

Modus-stelt in hoe de pin werkt. Bij de ingang (INVOER) of uitgang (OUTPUT). Om de LED te laten branden moeten we een signaal geven VAN Arduino. Om dit te doen, configureren we de uitvoerpin.
- deze functie wordt gebruikt om de status in te stellen (staat) pina (pinNummer). Er zijn twee hoofdstaten (eigenlijk drie), één is dat HOOG, er komt 5V op de pin, dat is iets anders Laag en de pin zal 0v zijn. Dit betekent dat om de LED te laten branden, we de pin die op de LED is aangesloten op een hoog niveau moeten instellen HOOG.

Vertraging. Dient om de werking van het programma te vertragen gedurende een periode gespecificeerd in msec.
Hieronder staat de code die de LED laat knipperen.
//LED Knippert int ledPin = 7;//Arduino-pin waarmee de LED is verbonden void setup() ( pinMode(ledPin, OUTPUT);// de pin instellen als OUTPUT) void loop() ( digitalWrite(ledPin, HIGH) ;// schakel de LED-vertraging in (1000);//vertraging 1000 ms (1 sec) digitalWrite (ledPin, LOW);// Schakel de LED-vertraging uit (1000); // wacht 1 sec)

Kleine uitleg over de code.
Regels die beginnen met "//" zijn commentaar en worden door Arduino genegeerd.
Alle opdrachten eindigen met een puntkomma; als u ze vergeet, krijgt u een foutmelding.

ledPin is een variabele. Variabelen worden in programma's gebruikt om waarden op te slaan. In dit voorbeeld de variabele ledPin de waarde is toegewezen aan 7, dit is het Arduino-pinnummer. Wanneer het Arduino-programma een regel met een variabele tegenkomt ledPin, zal het de waarde gebruiken die we eerder hebben opgegeven.
Dus opnemen pinModus(ledPin, UITGANG) vergelijkbaar met opnemen pinMode(7, UITGANG).
Maar in het eerste geval hoeft u alleen maar de variabele te wijzigen en deze verandert op elke regel waar deze wordt gebruikt, en in het tweede geval moet u, om de variabele te wijzigen, handmatig wijzigingen aanbrengen in elke opdracht.

De eerste regel geeft het type van de variabele aan. Bij het programmeren van Arduino is het belangrijk om altijd het type variabelen te declareren. Voor nu is het genoeg dat je dat weet INT kondigt negatieve en positieve cijfers aan.
Hieronder ziet u een simulatie van de schets. Klik op start om het circuit in actie te zien.

Zoals verwacht gaat de LED uit en gaat na één seconde weer aan. Probeer de vertraging te wijzigen om te zien hoe dit werkt.

Aansturing van meerdere LED's.

In dit voorbeeld leert u hoe u meerdere LED's kunt aansturen. Om dit te doen, installeert u nog 3 LED's op het bord en sluit u deze aan op weerstanden en Arduino-pinnen, zoals hieronder weergegeven.

Om de LED's één voor één aan en uit te zetten, moet je een programma schrijven dat er ongeveer zo uitziet:
//Multi LED Knippert int led1Pin = 4; int led2Pin = 5; int led3Pin = 6; int led4Pin = 7; void setup() ( //stel pinnen in als OUTPUT pinMode(led1Pin, OUTPUT); pinMode(led2Pin, OUTPUT); pinMode(led3Pin, OUTPUT); pinMode(led4Pin, OUTPUT); ) void loop() ( digitalWrite(led1Pin, HIGH );//zet de LED-vertraging aan (1000);//vertraging 1 sec digitalWrite(led1Pin, LOW);//zet de LED-vertraging uit (1000);//vertraging 1 sec //doe hetzelfde voor de andere 3 LED's digitalWrite(led2Pin, HIGH);//steek de LED-vertraging op(1000);//vertraging 1 sec digitalWrite(led2Pin, LOW);//doof de LED-vertraging(1000);//vertraging 1 sec digitalWrite(led3Pin, HIGH);//vertraging 1 sec digitalWrite(led3Pin, HIGH); );//de LED-vertraging aansteken(1000);//vertraging 1 sec digitalWrite(led3Pin, LOW);//de LED-vertraging doven(1000);//vertraging 1 sec digitalWrite(led4Pin, HIGH);//inschakelen de LED-vertraging (1000); // vertraging 1 sec digitalWrite (led4Pin, LOW); // doof de LED-vertraging (1000); // vertraging 1 sec)

Dit programma zal prima werken, maar het is niet de meest rationele oplossing. De code moet worden gewijzigd. Om het programma keer op keer te laten werken, zullen we een constructie gebruiken genaamd .
Loops zijn handig als u dezelfde actie meerdere keren moet herhalen. In de bovenstaande code herhalen we de regels

DigitalWrite(led4Pin, HOOG); vertraging(1000); digitalWrite(led4Pin, LAAG); vertraging(1000);
volledige schetscode in bijlage (downloads: 1187)

Aanpassing van de LED-helderheid

Soms moet u de helderheid van de LED's in het programma wijzigen. Dit kan gedaan worden met behulp van het commando analoogSchrijven() . Met dit commando wordt de LED zo snel aan- en uitgeschakeld dat het oog het flikkeren niet kan zien. Als de LED de helft van de tijd aanstaat en de helft van de tijd uit, zal het visueel lijken alsof hij op de helft van zijn helderheid gloeit. Dit wordt pulsbreedtemodulatie genoemd (PWM of PWM in het Engels). Shim wordt vrij vaak gebruikt, omdat hiermee een “analoge” component kan worden aangestuurd met behulp van een digitale code. Niet alle Arduino-pinnen zijn geschikt voor deze doeleinden. Alleen die conclusies waarbij een dergelijke aanduiding wordt getrokken " ~ ". Je ziet het naast pinnen 3,5,6,9,10,11.
Sluit een van je LED's aan op een van de PWM-pinnen (voor de auteur is dit pin 9). Voer nu de LED-knipperende schets uit, maar verander eerst het commando digitaalschrijven() op analoogSchrijven(). analoogSchrijven() heeft twee argumenten: het eerste is het pinnummer en het tweede is de PWM-waarde (0-255), in relatie tot LED's is dit hun helderheid, en voor elektromotoren de rotatiesnelheid. Hieronder vindt u een voorbeeldcode voor verschillende LED-helderheden.
//Verander de helderheid van de LED int ledPin = 9;//een LED is verbonden met deze pin void setup() ( pinMode(ledPin, OUTPUT);// initialiseert de pin naar de uitgang) void loop() ( analogWrite( ledPin, 255);// volledige helderheid (255/255 = 1) vertraging(1000);//pauze 1 sec digitalWrite(ledPin, LOW);//schakel LED vertraging uit(1000);//pauze 1 sec analogWrite( ledPin, 191);//helderheid met 3/4 (191/255 ~= 0,75) vertraging(1000);//pauze 1 sec digitalWrite(ledPin, LOW);//schakel de LED-vertraging uit(1000);// pauzeer 1 sec analogWrite(ledPin, 127); //halve helderheid (127/255 ~= 0,5) vertraging(1000);//pauzeer 1 sec digitalWrite(ledPin, LOW);//zet LED-vertraging uit(1000);/ /pauze 1 sec analogWrite(ledPin, 63); //kwart helderheid (63/255 ~= 0,25) vertraging(1000);//pauze 1 sec digitalWrite(ledPin, LOW);//zet de LED-vertraging uit(1000) ;//pauze 1 sec)

Probeer de PWM-waarde in de opdracht te wijzigen analoogSchrijven() om te zien hoe dit de helderheid beïnvloedt.
Vervolgens leert u hoe u de helderheid soepel kunt aanpassen van vol naar nul. Je kunt een stukje code uiteraard 255 keer kopiëren
analogWrite(ledPin, helderheid); vertraging(5);//korte vertraging helderheid = helderheid + 1;
Maar u begrijpt dat dit niet praktisch zal zijn. De beste manier om dit te doen is door de FOR-lus te gebruiken die we eerder hebben gebruikt.
In het volgende voorbeeld worden twee lussen gebruikt, één om de helderheid te verlagen van 255 naar 0
for (int helderheid=0;helderheid=0;helderheid--)( analogWrite(ledPin,helderheid); vertraging(5); )
vertraging(5) gebruikt om de fade-in-snelheid van de helderheid te vertragen 5*256=1280ms=1,28s)
De eerste regel gebruikt " helderheid-" om de helderheidswaarde elke keer dat de lus wordt herhaald met 1 te laten afnemen. Houd er rekening mee dat de lus doorloopt tot helderheid >=0.Het bord vervangen > op het bord >= we hebben 0 opgenomen in het helderheidsbereik. Deze schets is hieronder gemodelleerd. // verander de helderheid soepel int ledPin = 9; // een LED is verbonden met deze pin void setup () ( pinMode (ledPin, OUTPUT); // initialisatie van de uitvoerpin) void loop () ( // verhoog soepel de helderheid (0 tot 255) voor (int helderheid=0;helderheid=0;helderheid--)( analogWrite(ledPin,helderheid); vertraging(5); ) vertraging(1000);//wacht 1 sec //verlaag de helderheid soepel (255 tot 0) voor (int helderheid=255;helderheid>=0;helderheid--)( analogWrite(ledPin,helderheid); vertraging(5); ) vertraging(1000);//wacht 1 sec ) )
Het is niet erg zichtbaar, maar het idee is duidelijk.

RGB-LED en Arduino

Een RGB-LED zijn eigenlijk drie verschillend gekleurde LED's in één pakket.

Door verschillende LED's met verschillende helderheid in te schakelen, kun je ze combineren om verschillende kleuren te creëren. Voor Arduino, waar het aantal helderheidsniveaus 256 is, krijgt u 256^3=16581375 mogelijke kleuren. In werkelijkheid zullen het er uiteraard minder zijn.
De LED die we zullen gebruiken is de gemeenschappelijke kathode. Die. alle drie de LED's zijn structureel verbonden door kathodes met één terminal. We zullen deze pin verbinden met de GND-pin. De overige pinnen moeten via begrenzingsweerstanden worden aangesloten op de PWM-pinnen. De auteur gebruikte pinnen 9-11. Op deze manier is het mogelijk om elke LED afzonderlijk aan te sturen. De eerste schets laat zien hoe je elke LED afzonderlijk kunt inschakelen.

In het volgende voorbeeld worden de opdrachten gebruikt analoogSchrijven() en om verschillende willekeurige helderheidswaarden voor de LED's te krijgen. Je zult verschillende kleuren willekeurig zien veranderen.
//RGB LED - willekeurige kleuren //pinverbindingen int rood = 9; int groen = 10; int blauw = 11; void setup())( pinMode(rood, OUTPUT); pinMode(blauw, OUTPUT); pinMode(groen, OUTPUT); ) void loop())( //kies een willekeurige kleur analogWrite(rood, willekeurig(256)); analogWrite( blauw, willekeurig(256)); analogWrite(groen, willekeurig(256));

Willekeurig(256)-retourneert een willekeurig getal in het bereik van 0 tot 255.
In het bijgevoegde bestand vindt u een schets die vloeiende kleurovergangen demonstreert van rood naar groen, vervolgens naar blauw, rood, groen, enz. (downloads: 326)
De voorbeeldschets werkt, maar er is veel dubbele code. U kunt de code vereenvoudigen door uw eigen helperfunctie te schrijven die soepel van de ene kleur naar de andere verandert.
Hier ziet u hoe het eruit zal zien: (downloads: 365)
Laten we de functiedefinitie stukje bij beetje bekijken. De functie wordt aangeroepen fader en heeft twee argumenten. Elk argument wordt gescheiden door een komma en heeft een type dat op de eerste regel van de functiedefinitie wordt gedeclareerd: ongeldige fader (int kleur1, int kleur2). Je ziet dat beide argumenten worden gedeclareerd als int, en ze krijgen namen kleur1 En kleur2 als voorwaardevariabelen om een ​​functie te definiëren. Leegte betekent dat de functie geen waarden retourneert, maar eenvoudigweg opdrachten uitvoert. Als je een functie zou moeten schrijven die het resultaat van vermenigvuldiging teruggeeft, zou het er als volgt uitzien:
int multiplier(int getal1, int getal2)( int product = getal1*getal2; retourproduct; )
Merk op hoe we Type hebben verklaard int als retourtype
leegte.
Binnen de functie bevinden zich commando's die je al in de vorige schets hebt gebruikt, alleen de pincodes zijn vervangen kleur1 En kleur2. De functie wordt aangeroepen fader, worden de argumenten berekend als kleur1 = rood En kleur2 = groen. Het archief bevat een volledige schets met behulp van functies (downloads: 272)

Knop

De volgende schets gebruikt een knop met normaal open contacten, zonder vergrendeling.

analoogLezen Hiermee kunt u gegevens van een van de analoge Arduino-pinnen lezen en wordt een waarde weergegeven in het bereik van 0 (0V) tot 1023 (5V). Als de spanning op de analoge ingang 2,5V is, wordt 2,5 / 5 * 1023 = 512 afgedrukt
analoogLezen heeft slechts één argument - Dit is het nummer van de analoge ingang (A0-A5). De volgende schets toont de code voor het lezen van de spanning van de potentiometer. Om dit te doen, sluit u een variabele weerstand aan, de buitenste aansluitingen op de 5V- en GND-pinnen en de middelste aansluiting op de A0-ingang.

Voer de volgende code uit en zie in de seriële monitor hoe de waarden veranderen afhankelijk van de rotatie van de weerstandsknop.
//analoge ingang int potPin = A0;//de centrale pin van de potentiometer is verbonden met deze pin void setup())( //analoge pin is standaard opgenomen als invoer, dus initialisatie is niet nodig Serial.begin(9600 ); ) void loop())( int potVal = analogRead(potPin);//potVal is een getal tussen 0 en 1023 Serial.println(potVal)
De volgende schets combineert de schets van de knopklik en de schets van de LED-helderheidsregeling. De LED gaat aan via de knop en de helderheid wordt geregeld door een potentiometer.
//knopdrukdetectie met LED-uitgang en variabele intensiteit int buttonPin = 7; int ledPin = 9; int potPin = A0; void setup())( pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop())( if (digitalRead(buttonPin)==HIGH)(//if knop ingedrukt int analogVal = analogRead(potPin); int scaledVal = map(analogVal, 0, 1023, 0, 255); analogWrite(ledPin, scaledVal);//zet led aan met intensiteit ingesteld door pot Serial.println("pressed"); ( digitalWrite(ledPin, LOW);//uitschakelen als de knop niet wordt ingedrukt Serial.println("niet ingedrukt"); ) )