En laten we proberen een nieuwe taak te voltooien. Ik denk dat iedereen wel eens nieuwjaarsslingers heeft gezien waarin LED's soepel knipperen. Laten we zeggen dat we zoiets als dit willen doen.
We hebben al naar de functie digitalWrite() gekeken en weten dat de waarde die deze schrijft twee opties kan hebben: hoog of laag niveau. IN in dit geval De functie analogWrite() zal ons helpen. De "formuleringen" van functies verschillen alleen in de beginvoorvoegsels, dus ze zijn gemakkelijk te onthouden.
De functie analogWrite() bevat, net als digitalWrite(), twee argumenten tussen haakjes en werkt volgens hetzelfde verbale principe: “waar, wat”. Het belangrijkste verschil is de mogelijkheid om op te nemen breed bereik waarden in plaats van de gebruikelijke LAAG of HOOG. Hiermee kunnen we de helderheid van de LED aanpassen. Het belangrijkste punt om rekening mee te houden is dat deze functie werkt alleen door bepaalde contacten. Deze pinnen zijn gemarkeerd met een "~"-symbool. Dit symbool geeft aan dat dit een PWM-contact is. PWM (pulsbreedtemodulatie) klinkt als PWM (pulsbreedtemodulatie) in het Russisch. Het werkingsprincipe is gebaseerd op het wijzigen van de pulsduur. Grafisch kan dit als volgt worden weergegeven:
Laten we proberen erachter te komen hoe dit werkt door naar een eenvoudig voorbeeld te kijken. Om dit te doen, moet je de LED verbinden met het PWM-contact via een weerstand van 150 Ohm en deze “hardwire” in de Arduino een eenvoudig programma. Het aansluitschema en de schetscode vindt u hieronder:
ongeldige instellingen()
{
pinMode(led,OUTPUT);
}lege lus()
{
for(int i=0; ik<=255; i++)
{
analoogSchrijven(led,i);
vertraging(10);
}
for(int i=255; i>=0; ik--)
{
analoogSchrijven(led,i);
vertraging(10);
}
}
Ik denk dat de code over het algemeen duidelijk is, maar er moet wel wat aandacht aan worden besteed voor lus(). Er bestaat zoiets als toestemming. Omdat we met een 8-bits resolutie werken (dit zal later worden besproken), dan minimale waarde komt overeen met 0, en het maximum komt overeen met 255. Aan het einde van elke iteratie stellen we de tijdsvertraging in op 10 ms.
Laten we teruggaan naar het diagram uit de vorige les en proberen een soortgelijke slinger te maken met behulp van de functie analogWrite().
int-knopPin = 2;
int-pinnen = (3,5,6,9,10,11);boolean lastButton = LAAG;
Booleaanse currentButton = LAAG;
booleaanse enable = false;ongeldige instellingen()
{
pinMode(knopPin, INPUT);
for(int-modus = 0; modus<= 5; mode++) pinMode(pins, OUTPUT);
}Booleaanse debounce (Booleaanse laatste)
{
Booleaanse huidige = digitalRead(buttonPin);
if(laatste != huidig)
{
vertraging(5);
huidig = digitalRead(knopPin);
}
retourstroom;
}lege lus()
{
huidigeKnop = debounce(laatsteKnop);
if(laatsteKnop == LAAG && huidigeKnop == HOOG)
{
inschakelen =! inschakelen;
}Als(inschakelen == waar)
{
voor (int i=0; ik<=5; i++)
{
voor (int helderheid = 0; helderheid<= 255; brightness++)
{
vertraging(1);
}
vertraging(40);
}
voor (int i=0; ik<=5; i++)
{
voor (int helderheid = 255; helderheid >= 0; helderheid--)
{
analogWrite(pinnen[i], helderheid);
vertraging(1);
}
vertraging(40);
}
}Als(inschakelen == false)
{
voor(int i = 0; ik<= 5; i++) digitalWrite(pins[i], LOW);
}LaatsteKnop = huidigeKnop;
}
Visueel is de schets wat complexer geworden. In feite is alles hier eenvoudig en laten we het uitzoeken. We moeten alle aangesloten LED's identificeren, maar in plaats van de gebruikelijke int-led gebruiken we een array, waarvan elk element een PWM-pin op de Arduino is. In de hoofdtekst van de functie void setup() hebben we ook op een sluwe manier gehandeld. We hebben de “lijst” van alle contacten toevertrouwd aan de for()-lus, waarbij bij elke iteratie het corresponderende contact wordt geconfigureerd op OUTPUT. Laten we verder gaan met de functie void loop(). De debounce()-functie en de initiële if()-voorwaarde blijven ongewijzigd. We controleren nog steeds de niveaus van twee variabelen: de vorige waarde (aanvankelijk LAAG) en de huidige status van de knop. Wanneer aan deze voorwaarden wordt voldaan, wordt de waarde van de enable-variabele omgekeerd. Met dit in gedachten hebben we nog twee eenvoudige if()-voorwaarden toegevoegd. Als enable = true, dan wordt de slinger ingeschakeld, waarvan de vloeiendheid van de “flow” wordt geregeld door de for()-lus. Als enable = false, zijn alle LED's uitgeschakeld. Aan het einde van de voorwaarden neemt de variabele lastButton de huidige status van de knop over.
Tijdens het testen van ons programma merkten we dat alles niet werkte zoals verwacht. Weet je nog dat we in de vorige les een wijziging hebben aangebracht dat als de tijdsvertraging groot is, de knop wordt geactiveerd nadat deze is verstreken? In het vorige voorbeeld, toen de slinger werd ingeschakeld, was de totale vertraging in de hoofdtekst van de functie void loop() 85 ms. Dit gaf ons de mogelijkheid om binnen een bepaalde tijd ‘er te komen’. In deze schets verschilt de vertraging onder dezelfde voorwaarde verschillende keren. Misschien, als je de slinger wilt uitschakelen, komt het woord 'onderbreken' voor. Dit zal de oplossing zijn voor dit probleem!
Ik hoop dat dit artikel nuttig voor je was. In de volgende tutorial zullen we kijken naar interrupts in Arduino en het gewenste resultaat bereiken.
Pulsbreedtemodulatie (PWM) is leuk, en vooral leuk om te gebruiken om servo's te besturen, maar vandaag zullen we het toepassen op een driekleurige LED. Hierdoor kunnen we de kleur beheersen en een zekere schijn van schoonheid bereiken.
PWM
De definitie van PWM is op ingenieuze wijze geformuleerd op Wikipedia, dus ik kopieer het gewoon vanaf daar: "PWM- benadering van het gewenste signaal (meerdere niveaus of continu) met daadwerkelijke binaire signalen (met twee niveaus - aan/uit ), zodat hun waarden gemiddeld over een bepaalde periode gelijk zijn.
<...>
Sch IM is een pulssignaal met constante frequentie en variabele inschakelduur , dat wil zeggen de verhouding tussen de pulsherhalingsperiode en de duur ervan. Door het instellen van de duty-cycle (pulsduur)u kunt de gemiddelde spanning op de PWM-uitgang wijzigen.
"
Laten we nu eens kijken wat dit betekent. Laat er een gewoon rechthoekig signaal zijn zoals dit:
Het heeft een vaste frequentie en een duty-cycle van 50%. Dit betekent dat de helft van de periode de spanning maximaal is en de andere helft nul. Nadat we dit signaal over de periode hebben geïntegreerd, zien we dat de energie ervan gelijk is aan de helft van het maximum. Dit komt overeen met als we de hele tijd de helft van de spanning werd toegepast.
Als onze maximale spanning 5 V is, dan is de spanning die wordt verkregen aan de PWM-uitgang gelijk aan de duty-cycle vermenigvuldigd met 5 V (en gedeeld door 100% zodat formele nazi's niet gehecht raken):
Driekleurige LED
Hier is hij, een knappe man met vier poten:
Het langste been is de gemeenschappelijke anode, en al de rest zijn kathodes, elk verantwoordelijk voor zijn eigen kleur: (kijk naar de afbeelding) de onderste is rood, de tweede van boven is groen, de bovenste is blauw.
Als je +5V toepast op het lange been en 0V op alle andere, krijg je wit licht (ik smeek je, bescherm jezelf - installeer beperkende weerstanden!). Hoe wit het is, kun je beoordelen aan de hand van de volgende video:
Maar er een witte kleur op krijgen is gewoon niet interessant. Laten we eens kijken hoe we het in verschillende kleuren kunnen laten glinsteren.
PWM op Arduino
De PWM-frequentie op Arduino is ongeveer 490 Hz. Op het Arduino UNO-bord zijn de pinnen die kunnen worden gebruikt voor PWM 3,5,6, 9, 10 en 11. Er staat een hint hiervoor op het bord - er staat een tilde of scherp in zeefdruk vóór de PWM-pincodes .
Er is niets eenvoudiger dan PWM besturen op Arduino! Gebruik hiervoor één enkele functie analogWrite(pincode, waarde), Waar pin- pincode, en waarde- waarde van 0 tot 255. In dit geval hoeft u niets in te voeren ongeldige instellingen()!
U kunt hierover meer lezen in het Engels en.
Wij werken nogal wat
Laten we de LED in verschillende kleuren laten glinsteren. Laat de ene kleur vervagen terwijl de andere oplaait. We zullen een paar kleuren afwisselen, en de kleur zal in een cirkel bewegen van rood naar groen, van groen naar blauw, van blauw naar rood.
Laten we een eenvoudig diagram samenstellen:
En laten we wat eenvoudige code schrijven:
//noem de pinnen op basis van kleur
int REDpin = 9;
int GROENpin = 10;
int BLAUW pin = 11;
leegte opstelling
(){}
leegte lus
(){
voor (int waarde = 0; waarde<= 255; value +=1) {
//rode helderheid neemt af
analogWrite(REDpin, waarde);
//groene helderheid neemt toe
analogWrite(GREENpin, 255-waarde);
//blauw is uit
analoogSchrijven(BLAUWpin, 255);
//pauze
vertraging(30);
}
voor (int waarde = 0; waarde<= 255; value +=1) {
//rood is uit
analoogschrijven(REDpin, 255);
//groene helderheid neemt af
analogWrite(GROENpin, waarde);
//blauwe helderheid neemt toe
analogWrite(BLUEpin, 255-waarde);
//pauze
vertraging(30);
}
voor (int waarde = 0; waarde<= 255; value +=1) {
//rode helderheid neemt toe
analogWrite(REDpin, 255-waarde);
//groen is uit
analoogSchrijven(GROENpen, 255);
//blauwe helderheid neemt af
analogWrite(BLAUWpin, waarde);
//pauze
vertraging(30);
}
}
Ongeveer 3 maanden geleden kocht ik, zoals veel ongelukkige elektronica, naar mijn mening destijds het meest geavanceerde microprocessorbord uit de Arduino-familie, namelijk Seeeduino Mega, gebaseerd op de Atmega1280-processor. Nadat ik mezelf naar hartenlust had verwend met de roterende servoaandrijving en knipperende LED, rees de vraag: “waarom heb ik deze gekocht?”
Ik werk als een van de toonaangevende ontwerpers bij een grote militaire fabriek in Zelenograd en leid momenteel een project om een metrologisch meetinstrument te ontwikkelen. Er zijn een oneindig aantal problemen in deze taak die een individuele oplossing vereisen. Eén van deze taken is het aansturen van een stappenmotor zonder geluid en in stappen van niet 1,8 graden, zoals vermeld in de stappenmotordocumentatie, maar tot 0,0001 graden. Het lijkt erop dat het probleem complex en onoplosbaar is, maar nadat ik een beetje aan de besturingscircuits had gesleuteld, kwam ik tot de conclusie dat alles echt en mogelijk is. Het vereist slechts de generatie van twee signalen met een specifieke vorm en met een faseverschuiving en een spanningsveranderingsfrequentie van maximaal 1 MHz. (Ik zal een gedetailleerde studie van de stappenmotor schrijven en alle geheimen van de besturing onthullen in het volgende artikel) Onmiddellijk begonnen er sprankjes hoop in mijn hoofd te verschijnen dat ik niet tevergeefs 1.500 roebel had uitgegeven aan mijn kleine rode Seeeduino, en ik begon enthousiast te worden en begon het uit te zoeken.
Aanvankelijke horror:
Nadat ik het microprocessorbord op de oscilloscoop had aangesloten en een digitalWrite(HIGH)-cyclus had geschreven, en daaronder digitalWrite(LOW), vond ik op de oscilloscoop een nogal saaie blokgolf met een frequentie van 50 Hz. Het is een nachtmerrie. Dit is een ineenstorting, dacht ik, tegen de achtergrond van de vereiste 1 MHz.Vervolgens bestudeerde ik via een oscilloscoop nog een aantal uitvoeringssnelheden:
AnalogRead() - uitvoeringssnelheid 110 µs.
Analoog schrijven() - 2000 µs
SerialPrintLn() - bij snelheid 9600 ongeveer 250 µs, en bij maximale snelheid ongeveer 3 µs.
Digitaal schrijven() - 1800 µs
Digitaal lezen() - 1900 µs
Op dat moment barstte ik in tranen uit en gooide bijna mijn Seeeduino weg. Maar dat was niet het geval!
De ogen zijn bang, de handen doen het!
Ik zal je niet vertellen over mijn mentale angst en drie lange studiedagen beschrijven; het is beter om het gewoon te vertellen zoals het is!Nadat ik alle mogelijke documentatie over Arduino en de Atmega1280-processor heb opgezocht en de ervaringen van buitenlandse collega's heb onderzocht, wil ik graag enkele tips geven over het vervangen van lezen/schrijven:
AnalogRead() verbeteren
#define FASTADC 1// definieert voor het instellen en wissen van registerbits
#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif
Installatie ongeldig maken() (
int begin;
int ik;
#als FASTADC
// stel de voorschaal in op 16
sbi(ADCSRA,ADPS2) ;
cbi(ADCSRA,ADPS1) ;
cbi(ADCSRA,ADPS0) ;
#endif
Serieel.begin(9600) ;
Serieel.print("ADCTEST: ") ;
start = milli() ;
voor (ik = 0; ik< 30000 ; i++)
analoogLezen(0) ;
Serieel.print(millis() - start);
Serial.println("msec (30.000 oproepen)" ;
}
Ongeldige lus() (
}
Resultaat: snelheid 18,2 µs tegen exen 110 µs.
Overigens is de maximale snelheid van de Atmega ADC slechts 16 microseconden. Een alternatief is om een andere microschakeling te gebruiken, speciaal op maat gemaakt voor de ADC, die de snelheid zal verlagen 0,2 µs(lees hieronder waarom)
DigitalWrite() verbeteren
Elke Arduino/Seeeduino/Feduino/Orduino/otherduino heeft poorten. Elke poort is 8 bits, die eerst moet worden geconfigureerd voor opname. Bijvoorbeeld op mijn Seeeduino PORTA - van 22 tot 30 poten. Nu is alles eenvoudig. We besturen de benen 22 tot en met 30 met behulp van functiesPORTA=B00001010 (bit, poot 23 en 25 - HOOG)
of
PORTA=10 (decimaal, nog steeds hetzelfde)
Resultaat =0,2 µs tegen 1800 ons, die worden bereikt door gewone digitalWrite()
DigitaleRead() verbeteren
Bijna hetzelfde als in de verbetering met digitalWrite(), maar nu zetten we de poten op INPUT, en gebruiken we bijvoorbeeld:if (PINA==B00000010) (...) (als HIGH aanwezig is op etappe 23, en LOW aanwezig is op etappe 22 en 24-30)
Resultaat dit doen if() - 0,2 µs tegen 1900 µs, die worden bereikt door de gebruikelijke digitalRead()
Verbetering van de PWM-modulator of analogWrite()
Er zijn dus aanwijzingen dat digitalRead() wordt uitgevoerd in 0,2 µs en dat de PWM-modulator een resolutie heeft van 8 bits. De minimale PWM-schakeltijd is 51,2 µs versus 2000 µs.Wij gebruiken de volgende code:
int PWM_tijd=32; //Het nummer dat we naar analogWrite willen schrijven (PIN, 32)
voor (int k=0;k
Dus we hebben het PWM met frequentie 19 kHz tegen 50 Hz.
Laten we het samenvatten
digitalWrite() was 1800 ons, het werd 0,2 µsdigitalRead() was 1900 µs, het werd 0,2 µs
analoogWrite() was 2000 ons, het werd 51,2 µs
analogRead() was 110 µs, het werd 18,2 µs, of misschien tot 0,2 µs
Bijvoorbeeld);
Instructies voor het gebruik van PWM in Arduino
1 Algemene informatie over pulsbreedtemodulatie
Arduino digitale pinnen kunnen slechts twee waarden uitvoeren: logisch 0 (LAAG) en logisch 1 (HOOG). Daarom zijn ze digitaal. Maar Arduino heeft “speciale” pinnen, die zijn aangewezen PWM. Ze worden soms aangegeven met een golvende lijn "~" of omcirkeld of anderszins onderscheiden van anderen. PWM staat voor Pulsbreedtemodulatie of pulsbreedtemodulatie, PWM.
Een pulsbreedtegemoduleerd signaal is een pulssignaal met een constante frequentie, maar variabel inschakelduur(de verhouding tussen de pulsduur en de herhalingsperiode ervan). Vanwege het feit dat de meeste fysieke processen in de natuur traagheid hebben, zullen plotselinge spanningsdalingen van 1 naar 0 worden afgevlakt en een gemiddelde waarde aannemen. Door de dutycycle in te stellen, kunt u de gemiddelde spanning aan de PWM-uitgang wijzigen.
Als de duty-cycle 100% is, zal de digitale uitgang van de Arduino altijd een logische spanning van “1” of 5 volt hebben. Als u de inschakelduur instelt op 50%, is de uitvoer de helft van de tijd logisch "1" en de helft van de tijd - logisch "0", en de gemiddelde spanning is 2,5 volt. En zo verder.
In het programma wordt de duty-cycle niet als percentage opgegeven, maar als een getal van 0 tot 255. De opdracht analoogSchrijven(10, 64) zal de microcontroller vertellen een signaal met een dutycycle van 25% naar digitale PWM-uitgang nr. 10 te sturen.
Arduino-pinnen met pulsbreedtemodulatiefunctie werken op een frequentie van ongeveer 500 Hz. Dit betekent dat de pulsherhalingsperiode ongeveer 2 milliseconden bedraagt, wat wordt gemeten door de groene verticale strepen in de figuur.
Het blijkt dat we een analoog signaal op een digitale uitgang kunnen simuleren! Interessant, nietwaar?!Hoe kunnen we PWM gebruiken? Veel toepassingen! Regel bijvoorbeeld de helderheid van de LED, de rotatiesnelheid van de motor, de stroom van de transistor, het geluid van de piëzo-emitter, enz....
2 Diagram voor demonstratie Pulsbreedtemodulatie in Arduino
Laten we eens kijken naar het meest eenvoudige voorbeeld: het regelen van de helderheid van een LED met behulp van PWM. Laten we een klassiek schema samenstellen.
3 Schets voorbeeld met PWM
Laten we de schets "Fade" uit de voorbeelden openen: Bestandsvoorbeelden 01.Basis Fade.
Laten we het een beetje veranderen en in het Arduino-geheugen laden.
Int ledPin = 3; // declareer een pin die de LED int-helderheid regelt = 0; // variabele voor het instellen van de helderheid int fadeAmount = 5; // stap voor het wijzigen van de helderheid ongeldige setup() ( pinMode(ledPin, UITGANG); } lege lus() ( analogWrite(ledPin, helderheid); // stel de helderheid in op de ledPin-pinhelderheid += fadeAmount; // verander de helderheidswaarde /* bij het bereiken van de limieten 0 of 255, verander de richting van de helderheidsverandering */ if (helderheid == 0 || helderheid == 255) ( fadeAmount = -fadeAmount; // verander het teken van de stap ) vertraging(30); // vertraging voor een betere zichtbaarheid van het effect }
4 LED-helderheidsregeling met behulp van PWM en Arduino
Schakel de stroom in. De LED verhoogt geleidelijk de helderheid en neemt vervolgens geleidelijk af. We hebben een analoog signaal aan de digitale uitgang gesimuleerd met behulp van pulsbreedtemodulatie.
Bekijk de bijgevoegde video, waarin duidelijk de verandering in de helderheid van de LED te zien is; op de aangesloten oscilloscoop kun je zien hoe het signaal van de Arduino verandert.
Pulsbreedtemodulatie (PWM) van Arduino UNO en NANO werkt op analoge uitgangen 3, 5, 6, 9, 10, 11 met een frequentie van 488,28 Hz. Met behulp van de analogWrite-functie varieert de PWM-frequentie van 0 tot 255 en komt overeen met een puls-dutycycle van 0 tot 100%. Voor veel apparaten is de Arduino NANO PWM-frequentie te laag, dus deze moet worden verhoogd. Laten we eens kijken hoe we dit correct kunnen doen.
Arduino-pulsbreedtemodulatie
PWM, in het Engels Pulse-Width Modulation (PWM), is de regeling van het vermogen van de belasting door de duty-cycle (breedte) van pulsen te veranderen bij een constante frequentie en amplitude van het signaal. De volgende grafiek laat zien dat bij verschillende waarden in de analogWrite-functie de amplitude van de pulsen constant blijft, maar de breedte van de pulsen verandert. Het signaalvermogen bepaalt de duty-cycle van de puls.
Schema. Signaalparameters, PWM-dutycycle
Er zijn twee toepassingsgebieden van pulsbreedtemodulatie:
1. PWM wordt gebruikt in voedingen, stroomregelaars, enz. Het gebruik van PWM op de Arduino Nano kan de regeling van de helderheid van lichtbronnen (LED's, LED-strips) en de rotatiesnelheid van de motoren aanzienlijk vereenvoudigen.
2. PWM wordt gebruikt om een analoog signaal te ontvangen. Een digitaal-naar-analoog converter (DAC) op Arduino is eenvoudig te implementeren, omdat er een minimum aan radio-elementen nodig is - slechts één RC-keten van een weerstand en condensator is voldoende.
De Arduino PWM-frequentie wijzigen (bitgrootte)
Arduino Uno- en Arduino Nano-kaarten gebaseerd op ATmega168/328 hebben 6 hardware PWM-modulatoren op de analoge poorten 3, 5, 6, 9, 10, 11. Het PWM-signaal wordt bestuurd met behulp van de analogWrite-functie, die een analoog signaal genereert aan de uitgang en stelt de duty-cycle-impuls in. Arduino stelt de pinfrequentie in op 488,28 Hz en de resolutie op 8 bits (van 0 tot 255).
Schema. Pulsbreedtemodulatie voor dummies Arduino gebaseerd op ATmega168/328 gebruikt drie timers voor PWM:
Timer 0— conclusies 5 en 6
Timer 1— conclusies 9 en 10
Timer 2— conclusies 3 en 11
Arduino PWM wordt bepaald door geïntegreerde componenten die timers worden genoemd. Elke timer in de Arduino Uno- en Nano-kaarten op basis van de ATmega168/328-microcontroller heeft twee kanalen die op de uitgangen zijn aangesloten. Om de frequentie van een PWM-signaal te wijzigen, moet u de timer wijzigen waarmee het is verbonden. In dit geval zal de PWM ook veranderen op de analoge uitgangen die parallel zijn aangesloten op dezelfde timer.
Hoe u de frequentie en bitdiepte van Arduino PWM kunt verhogen
Er is geen manier om de Arduino PWM-frequentie te wijzigen zonder het geheugen rechtstreeks op een laag niveau te beheren. Laten we verder kijken hoe we de werkingsmodus van de timer kunnen wijzigen om de Arduino PWM-frequentie te verhogen. Timer 0 gebruikt om de tijd te berekenen, d.w.z. delay- en millis-functies. Het verhogen van de frequentie op Timer 0 zal de tijdbesparende functies die in de schets kunnen worden gebruikt, verbreken.
Om de Arduino-bitcapaciteit op analoge uitgangen 9 en 10 te vergroten, wijzigt u de frequentie Timer 1 zonder bibliotheek. De maximale PWM-frequentie kan 62.500 Hz bereiken op Arduino Uno- en Nano-kaarten. Om dit te doen, moet u in de void setup() procedure de juiste opdracht uit de onderstaande tabel toevoegen.
| Toestemming | PWM-frequentie | Opdrachten voor modusinstelling |
| 8 bit | 62.500 Hz | TCCR1A = TCCR1A & 0xe0 | 1; TCCR1B = TCCR1B & 0xe0 | 0x09; |
| 7.812,5 Hz | TCCR1A = TCCR1A & 0xe0 | 1; TCCR1B = TCCR1B & 0xe0 | 0x0a; |
|
| 976,56 Hz | TCCR1A = TCCR1A & 0xe0 | 1; TCCR1B = TCCR1B & 0xe0 | 0x0b; |
|
| 244,14 Hz | TCCR1A = TCCR1A & 0xe0 | 1; TCCR1B = TCCR1B & 0xe0 | 0x0c; |
|
| 61,04 Hz | TCCR1A = TCCR1A & 0xe0 | 1; TCCR1B = TCCR1B & 0xe0 | 0x0d; |
De maximale Arduino PWM-frequentie is 62.500 Hz.
