Kuongeza mzunguko wa Arduino PWM. Tunamiliki PWM katika kampuni ya joto ya Arduino na RGB LED. Maagizo ya kutumia PWM katika Arduino

Na tujaribu kukamilisha kazi mpya. Nadhani kila mtu ameona maonyesho ya maua ya Mwaka Mpya ambayo LEDs humeta vizuri. Wacha tuseme tunataka kufanya kitu kama hiki.
Tayari tumeangalia kazi ya digitalWrite() na tunajua kuwa thamani inayoandika inaweza kuwa ya chaguzi mbili - juu au kiwango cha chini. KATIKA kwa kesi hii Kazi ya analogWrite() itatusaidia. "Miundo" ya kazi hutofautiana tu katika viambishi awali, hivyo ni rahisi kukumbuka.

Chaguo za kukokotoa za analogWrite(), kama vile digitalWrite(), ina hoja mbili kwenye mabano na hufanya kazi kwa kanuni sawa ya maneno: "wapi, nini". Tofauti kuu ni uwezo wa kurekodi mbalimbali thamani badala ya LOW au HIGH ya kawaida. Hii itatuwezesha kurekebisha mwangaza wa LED. Jambo kuu la kuzingatia ni hilo kipengele hiki inafanya kazi tu mawasiliano fulani. Pini hizi zimewekwa alama ya "~". Alama hii inaonyesha kuwa huyu ni mwasiliani wa PWM. PWM (urekebishaji wa upana wa mapigo) inaonekana kama PWM (urekebishaji wa upana wa mapigo) kwa Kirusi. Kanuni ya uendeshaji inategemea kubadilisha muda wa pigo. Kielelezo hii inaweza kuonyeshwa kama hii:

Wacha tujaribu kujua jinsi hii inavyofanya kazi kwa kuangalia mfano rahisi. Ili kufanya hivyo, unahitaji kuunganisha LED kwa mawasiliano ya PWM kwa njia ya kupinga 150 Ohm na "hardwire" ndani ya Arduino. programu rahisi. Mchoro wa uunganisho na msimbo wa mchoro umewasilishwa hapa chini:


usanidi utupu ()
{
pinMode(inaongozwa, OUTPUT);
}

kitanzi utupu()
{
kwa (int i=0; i<=255; i++)
{
analogWrite(inaongozwa,i);
kuchelewa (10);
}
kwa(int i=255; i>=0; i--)
{
analogWrite(inaongozwa,i);
kuchelewa (10);
}
}


Nadhani kanuni kwa ujumla ni wazi, lakini tahadhari kidogo inahitaji kulipwa kwa kitanzi(). Kuna kitu kama ruhusa. Kwa kuwa tunafanya kazi na azimio la 8-bit (hii itajadiliwa baadaye kidogo), basi thamani ya chini itafanana na 0, na kiwango cha juu kitafanana na 255. Mwishoni mwa kila iteration, tunaweka kuchelewa kwa muda hadi 10ms.

Wacha turudi kwenye mchoro kutoka kwa somo lililopita na jaribu kutengeneza taji kama hiyo kwa kutumia kazi ya analogWrite().


int buttonPin = 2;
pini za int = (3,5,6,9,10,11);

boolean lastButton = CHINI;
boolean currentButton = CHINI;
boolean wezesha = uongo;

usanidi utupu ()
{
pinMode(buttonPin, INPUT);
for(int mode = 0; mode<= 5; mode++) pinMode(pins, OUTPUT);
}

debounce boolean (boolean mwisho)
{
boolean sasa = digitalRead(buttonPin);
ikiwa (mwisho != sasa)
{
kuchelewa (5);
sasa = digitalRead(buttonPin);
}
kurudi sasa;
}

kitanzi utupu()
{
currentButton = debounce(lastButton);
if(lastButton == CHINI && currentButton == JUU)
{
wezesha = !wezesha;
}

Ikiwa (wezesha == kweli)
{
kwa (int i=0; i<=5; i++)
{
kwa (inti mwangaza = 0; mwangaza<= 255; brightness++)
{
kuchelewa (1);
}
kuchelewa (40);
}
kwa (int i=0; i<=5; i++)
{
kwa (inti mwangaza = 255; mwangaza >= 0; mwangaza--)
{
analogWrite(pini[i], mwangaza);
kuchelewa (1);
}
kuchelewa (40);
}
}

Ikiwa (wezesha == uongo)
{
kwa (int i = 0; i<= 5; i++) digitalWrite(pins[i], LOW);
}

LastButton = currentButton;
}


Kwa kuibua mchoro umekuwa mgumu zaidi. Kwa kweli, kila kitu ni rahisi hapa na wacha tufikirie. Tunahitaji kutambua LED zote zilizounganishwa, lakini badala ya int led ya kawaida tunatumia safu, kila kipengele ambacho ni pini ya PWM kwenye Arduino. Katika mwili wa usanidi wa utupu () kazi, pia tulifanya kwa njia ya ujanja. Tulikabidhi "orodha" ya waasiliani wote kwa kitanzi cha (), na kila marudio ambayo anwani inayolingana husanidiwa kwenye OUTPUT. Wacha tuendelee kwenye kazi ya void loop(). Chaguo la kukokotoa () na hali ya awali if() halijabadilika. Bado tunaangalia viwango vya vigezo viwili: thamani ya awali (awali LOW) na hali ya sasa ya kifungo. Wakati masharti haya yametimizwa, thamani ya kigezo cha kuwezesha hugeuzwa. Kwa kuzingatia hili, tumeongeza hali mbili rahisi zaidi if() masharti. Ikiwa wezesha = kweli, basi taji huwashwa, ulaini wa "mtiririko" ambao unadhibitiwa na kitanzi cha (). Ikiwa wezesha = uongo, basi LED zote zimezimwa. Mwishoni mwa masharti, mabadiliko ya Kitufe cha mwisho huchukua hali ya sasa ya kitufe.
Wakati wa kujaribu programu yetu, tuligundua kuwa kila kitu hakifanyi kazi kama ilivyotarajiwa. Kumbuka, katika somo lililopita tulifanya marekebisho kwamba ikiwa kuchelewa kwa muda ni kubwa, kifungo kitawaka baada ya muda wake kuisha? Katika mfano uliopita, wakati taji ya maua iliwashwa, kuchelewa kwa jumla katika mwili wa void loop() kitendakazi ilikuwa 85ms. Hii ilitupa fursa ya "kufika huko" ndani ya muda fulani. Katika mchoro huu, chini ya hali sawa, kuchelewa hutofautiana mara kadhaa. Labda, ikiwa unataka kuzima taji, neno "kusumbua" linajipendekeza. Hili litakuwa suluhisho la tatizo hili!

Natumaini makala hii ilikuwa na manufaa kwako. Katika somo linalofuata tutaangalia usumbufu katika Arduino na kufikia matokeo unayotaka.

Urekebishaji wa upana wa mapigo ya moyo (PWM) ni ya kufurahisha, na inafurahisha sana kutumia kudhibiti servos, lakini leo tutaitumia kwa LED ya rangi tatu. Hii itaturuhusu kudhibiti rangi yake na kufikia mwonekano fulani wa uzuri.

PWM

Ufafanuzi wa PWM umeundwa kwa ustadi katika Wikipedia, kwa hivyo nitainakili kutoka hapo: "PWM - Ukadiriaji wa ishara inayotaka (ya ngazi nyingi au inayoendelea) kwa ishara halisi za binary (na viwango viwili - washa zima ), ili, kwa wastani, kwa muda fulani, maadili yao ni sawa. <...> Sh IM ni ishara ya mapigo ya mzunguko wa mara kwa mara na kutofautiana mzunguko wa wajibu , yaani, uwiano wa kipindi cha kurudia mapigo kwa muda wake. Kwa kuweka mzunguko wa wajibu (muda wa mapigo)unaweza kubadilisha voltage wastani kwenye pato la PWM. "


Sasa hebu tuone hii inamaanisha nini. Acha kuwe na ishara ya kawaida ya mstatili kama hii:




Ina mzunguko wa kudumu na mzunguko wa wajibu wa 50%. Hii ina maana kwamba nusu ya kipindi cha voltage ni kiwango cha juu, na nusu nyingine ni sifuri. Baada ya kuunganisha ishara hii kwa kipindi hicho, tunaona kwamba nishati yake ni sawa na nusu ya juu. Hii itakuwa sawa na kama sisi kila wakati nusu ya voltage ilitumika.


Ikiwa kiwango cha juu cha voltage yetu ni 5 V, basi voltage inayopatikana kwenye pato la PWM ni sawa na mzunguko wa wajibu uliozidishwa na 5 V (na kugawanywa na 100% ili Wanazi rasmi wasiunganishwe):


Arduino inakuwezesha kuandika thamani kutoka 0 hadi 255 kwa pato la PWM, ambayo ina maana kwamba tunaweza kupata voltage na azimio la takriban 20 mV.


LED ya rangi tatu

Huyu hapa, mtu mzuri wa miguu minne:


Mguu mrefu zaidi ni anode ya kawaida, na wengine wote ni cathodes, kila mmoja anajibika kwa rangi yake mwenyewe: (angalia picha) moja ya chini ni nyekundu, ya pili kutoka juu ni ya kijani, ya juu ni ya bluu.

Ikiwa unatumia +5V kwa mguu mrefu na 0V kwa wengine wote, utapata mwanga mweupe (nakusihi, jilinde - weka vikwazo vya kuzuia!). Jinsi nyeupe ni inaweza kuhukumiwa na video ifuatayo:


Lakini kupata rangi nyeupe juu yake sio tu kuvutia. Hebu tuone jinsi ya kufanya hivyo shimmer katika rangi tofauti.

PWM kwenye Arduino

Masafa ya PWM kwenye Arduino ni takriban 490 Hz. Kwenye ubao wa Arduino UNO, pini zinazoweza kutumika kwa PWM ni 3,5,6, 9, 10 na 11. Kuna kidokezo cha hili kwenye ubao - kuna tilde au mkali katika hariri kabla ya nambari za pini za PWM. .

Hakuna kitu rahisi kuliko kudhibiti PWM kwenye Arduino! Ili kufanya hivyo, tumia kazi moja analogiAndika(pini, thamani), Wapi pini- nambari ya siri, na thamani- thamani kutoka 0 hadi 255. Katika kesi hii, huna haja ya kuandika chochote usanidi utupu ()!

Unaweza kusoma zaidi kuhusu hili kwa Kiingereza na.

Tunafanya kazi kidogo

Hebu tufanye shimmer ya LED katika rangi tofauti. Acha rangi moja iishe huku nyingine ikiwaka. Tutabadilisha rangi kadhaa, na rangi itasonga kwenye mduara kutoka nyekundu hadi kijani, kutoka kijani hadi bluu, kutoka bluu hadi nyekundu.

Wacha tuweke mchoro rahisi:


Na wacha tuandike nambari rahisi:

// taja pini kulingana na rangi
int REDpin = 9;
int GREENpin = 10;
int BLUEpin = 11;

utupu kuanzisha (){}

utupu kitanzi (){
kwa ( thamani ya int = 0 ; thamani<= 255; value +=1) {
// mwangaza nyekundu hupungua
analogWrite(REDpin, value);
// mwangaza wa kijani huongezeka
analogWrite(GREENpin, 255-thamani);
//bluu imezimwa
analogWrite(BLUEpin, 255);
//sitisha
kuchelewa (30);
}

kwa ( thamani ya int = 0 ; thamani<= 255; value +=1) {
//nyekundu imezimwa
analogWrite(REDpin, 255);
// mwangaza wa kijani hupungua
analogWrite(GREENpin, thamani);
// mwangaza wa bluu huongezeka
analogWrite(BLUEpin, 255-thamani);
//sitisha
kuchelewa (30);
}

kwa ( thamani ya int = 0 ; thamani<= 255; value +=1) {
// mwangaza nyekundu huongezeka
analogWrite(REDpin, 255-thamani);
//kijani kimezimwa
analogWrite(GREENpin, 255);
// mwangaza wa bluu hupungua
analogWrite(BLUEpin, thamani);
//sitisha
kuchelewa (30);
}
}

Karibu miezi 3 iliyopita, kama vifaa vingi vya elektroniki vya bahati mbaya, nilinunua mwenyewe, kwa maoni yangu wakati huo, bodi ya kisasa zaidi ya microprocessor kutoka kwa familia ya Arduino, ambayo ni Seeduino Mega, kulingana na processor ya Atmega1280. Baada ya kujifurahisha kwa maudhui ya moyo wangu na gari la servo linalozunguka na blinking LED, swali lilitokea: "kwa nini niliinunua?"

Ninafanya kazi kama mmoja wa wabunifu wakuu katika kiwanda kikubwa cha kijeshi huko Zelenograd, na kwa sasa ninaongoza mradi wa kutengeneza chombo cha kupimia metrolojia. Kuna idadi isiyo na kipimo ya matatizo katika kazi hii ambayo yanahitaji ufumbuzi wa mtu binafsi. Moja ya kazi hizi ni kudhibiti motor stepper bila kelele na katika hatua si ya digrii 1.8, kama ilivyoelezwa katika nyaraka stepper motor, lakini hadi digrii 0.0001. Inaweza kuonekana kuwa tatizo ni ngumu na haliwezi kutatuliwa, lakini baada ya kuchezea kidogo na nyaya za udhibiti, nilifikia hitimisho kwamba kila kitu ni kweli na kinawezekana. Inahitaji tu kizazi cha ishara mbili za sura maalum na kwa mabadiliko ya awamu na mzunguko wa mabadiliko ya voltage hadi 1 MHz. (Nitaandika uchunguzi wa kina wa motor stepper na kufunua siri zote za udhibiti katika makala inayofuata) Mara moja, mwanga wa matumaini ulianza kuonekana katika kichwa changu kwamba sikuwa nimetumia rubles 1,500 bure kwenye Seeeduino yangu nyekundu, na mimi, nikipata shauku, nikaanza kubaini.

Hofu ya Awali:

Baada ya kuunganisha ubao wa microprocessor kwenye oscilloscope, na kuandika mzunguko wa DijitaliWrite(HIGH), na chini ya DijitaliWrite(LOW), nilipata wimbi la mraba lisilo na nguvu lenye mzunguko wa 50Hz kwenye oscilloscope. Jinamizi. Hii ni kuanguka, nilidhani, dhidi ya historia ya 1 MHz inayohitajika.
Ifuatayo, kupitia oscilloscope, nilisoma kasi kadhaa zaidi za utekelezaji:
AnalogRead() - kasi ya utekelezaji 110 µs.
AnalogWrite() - 2000 µs
SerialPrintLn() - kwa kasi 9600 kuhusu 250 µs, na kwa kasi ya juu kuhusu 3 µs.
DigitalWrite() - 1800µs
DigitalRead() - 1900µs

Kwa wakati huu, nilitokwa na machozi na karibu niitupe Seeduino yangu. Lakini haikuwepo!

Huwezi kujua unachoweza kufanya hadi ujaribu!

Sitakuambia juu ya uchungu wangu wa kiakili na kuelezea siku tatu ndefu za masomo;
Baada ya kuangalia nyaraka zote zinazowezekana kwenye Arduino na kichakataji cha Atmega1280, na kutafiti uzoefu wa wenzangu wa kigeni, ningependa kutoa vidokezo juu ya jinsi ya kuchukua nafasi ya kusoma/kuandika:
Kuboresha AnalogRead()
#fafanua FASTADC 1

// inafafanua kwa kuweka na kusafisha bits za rejista
#ifndef cbi
#fafanua cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#fafanua sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif

Uwekaji tupu () (
int kuanza;
int i;

#kama FASTDC
// weka kiwango cha awali hadi 16
sbi(ADCSRA,ADPS2);
cbi(ADCSRA,ADPS1);
cbi(ADCSRA,ADPS0);
#endif

Serial.begin(9600);
Serial.print("ADCTEST: ") ;
start = millis() ;
kwa (i = 0; i< 30000 ; i++)
analogRead(0) ;
Serial.print(millis() - start);
Serial.println(" msec (simu 30000)" ;
}

Kitanzi tupu() (
}

Matokeo: kasi 18.2µs dhidi ya ex 110µs.
Kwa njia, kasi ya juu ya Atmega ADC ni microseconds 16 tu. Njia mbadala ni kutumia microcircuit nyingine, iliyoundwa mahsusi kwa ADC, ambayo itapunguza kasi 0.2µs(soma hapa chini kwanini)

Kuboresha DijitaliWrite()
Kila Arduino/Seeeduino/Feduino/Orduino/otherduino ina bandari. Kila mlango una biti 8, ambazo lazima kwanza zisanidiwe kwa ajili ya kurekodi. Kwa mfano, kwenye Seeeduino PORTA yangu - kutoka kwa miguu 22 hadi 30. Sasa kila kitu ni rahisi. Tunadhibiti miguu 22 hadi 30 kwa kutumia kazi
PORTA=B00001010 (kidogo, miguu 23 na 25 - JUU)
au
PORTA=10 (desimali, bado ni sawa)
Matokeo =0.2µs dhidi ya 1800us, ambayo hupatikana kwa kawaida digitalWrite()
Kuboresha DijitaliRead()
Karibu sawa na katika uboreshaji na digitalWrite(), lakini sasa tunaweka miguu kwa INPUT, na kutumia, kwa mfano:
ikiwa (PINA==B00000010) (...) (ikiwa HIGH ipo kwenye mguu wa 23, na LOW ipo kwenye mguu wa 22 na 24-30)
Matokeo kufanya hivi ikiwa() - 0.2µs dhidi ya 1900µs, ambayo inafikiwa na kawaida ya digitalRead()
Kuboresha moduli ya PWM, au analogWrite()
Kwa hivyo, kuna ushahidi kwamba digitalRead() hutekeleza katika 0.2 µs, na moduli ya PWM ina azimio la biti 8, muda wa chini wa kubadili PWM ni 51.2 µs dhidi ya 2000 µs.
Tunatumia nambari ifuatayo:
int PWM_time=32; //Nambari tunayotaka kuiandikia analogWrite(PIN, 32)
kwa (int k=0;k Kwa (int k=0;k<256-PWM_time) PORTA=B00000000;

Kwa hivyo tulipata PWM yenye mzunguko 19 kHz dhidi ya 50 Hz.

Hebu tujumuishe

digitalWrite() ilikuwa 1800us, ikawa 0.2µs
digitalRead() ilikuwa 1900µs, ikawa 0.2µs
analogWrite() ilikuwa 2000us, ikawa 51.2µs
analogRead() ilikuwa 110μs, ikawa 18.2µs, au labda mpaka 0.2µs

Kwa mfano);

  • kupinga kwa thamani ya majina ya 190 ... 240 Ohms (hapa ni seti bora ya kupinga na maadili ya kawaida);
  • kompyuta binafsi na mazingira ya maendeleo ya Arduino IDE.

    • Maagizo ya kutumia PWM katika Arduino

    1 Habari za jumla kuhusu urekebishaji wa upana wa mapigo

    Pini za kidijitali za Arduino zinaweza kutoa tu thamani mbili: mantiki 0 (LOW) na mantiki 1 (JUU). Ndio maana ni za kidijitali. Lakini Arduino ina pini "maalum", ambazo zimeteuliwa PWM. Wakati mwingine huonyeshwa kwa mstari wa wavy "~" au kuzungushwa au kutofautishwa vinginevyo na wengine. PWM inasimama kwa Urekebishaji wa upana wa mapigo au urekebishaji wa upana wa mapigo, PWM.

    Ishara ya modulated ya upana wa pigo ni ishara ya mapigo ya mzunguko wa mara kwa mara, lakini kutofautiana mzunguko wa wajibu(uwiano wa muda wa mapigo na kipindi cha kurudia kwake). Kutokana na ukweli kwamba michakato mingi ya kimwili katika asili ina hali, matone ya ghafla ya voltage kutoka 1 hadi 0 yatapunguzwa, kuchukua thamani fulani ya wastani. Kwa kuweka mzunguko wa wajibu, unaweza kubadilisha voltage wastani kwenye pato la PWM.

    Ikiwa mzunguko wa wajibu ni 100%, basi pato la digital la Arduino daima litakuwa na voltage ya mantiki ya "1" au 5 volts. Ikiwa utaweka mzunguko wa wajibu kwa 50%, basi nusu ya muda wa pato itakuwa mantiki "1" na nusu ya muda - mantiki "0", na wastani wa voltage itakuwa 2.5 volts. Nakadhalika.


    Katika mpango huo, mzunguko wa wajibu hauonyeshwa kama asilimia, lakini kama nambari kutoka 0 hadi 255. Kwa mfano, amri. AnalogiAndika(10, 64) itamwambia kidhibiti kidogo kutuma mawimbi yenye mzunguko wa wajibu wa 25% kwa pato la digitali la PWM Nambari 10.

    Pini za Arduino zilizo na kazi ya kurekebisha upana wa mapigo hufanya kazi kwa mzunguko wa takriban Hz 500. Hii ina maana kwamba muda wa kurudia mapigo ni kuhusu milisekunde 2, ambayo hupimwa na viharusi vya wima vya kijani kwenye takwimu.

    Inatokea kwamba tunaweza kuiga ishara ya analog kwenye pato la digital! Inavutia, sivyo?!

    Tunawezaje kutumia PWM? Maombi mengi! Kwa mfano, dhibiti mwangaza wa LED, kasi ya kuzungusha motor, transistor mkondo, sauti kutoka kwa emitter ya piezo, nk...

    2 Mchoro wa maonyesho Urekebishaji wa upana wa Pulse katika Arduino

    Hebu tuangalie mfano wa msingi zaidi - kudhibiti mwangaza wa LED kwa kutumia PWM. Hebu tuweke pamoja mpango wa classic.


    3 Mfano wa mchoro pamoja na PWM

    Wacha tufungue mchoro wa "Fade" kutoka kwa mifano: Sampuli za Faili 01.Misingi Inafifia.


    Wacha tuibadilishe kidogo na kuipakia kwenye kumbukumbu ya Arduino.

    Int ledPin = 3; // tangaza pini inayodhibiti mwangaza wa int wa LED = 0; // kutofautiana kwa kuweka mwangaza int fadeAmount = 5; // hatua ya mabadiliko ya mwangaza usanidi utupu () ( pinMode(ledPin, OUTPUT); } kitanzi utupu() ( analogWrite(ledPin, mwangaza); // weka mwangaza kwenye pini ya ledPin mwangaza += fadeAmount; // badilisha thamani ya mwangaza /* unapofikia kikomo 0 au 255, badilisha mwelekeo wa mabadiliko ya mwangaza */ ikiwa (mwangaza == 0 || mwangaza == 255) ( fadeAmount = -fadeAmount; // badilisha ishara ya hatua ) kuchelewa(30); // kuchelewa kwa mwonekano mkubwa wa athari }

    4 Udhibiti wa mwangaza wa LED kutumia PWM na Arduino

    Washa nguvu. LED hatua kwa hatua huongeza mwangaza na kisha hupungua vizuri. Tuliiga mawimbi ya analogi kwenye toleo la dijitali kwa kutumia urekebishaji wa upana wa mapigo.


    Tazama video iliyoambatanishwa, ambayo inaonyesha wazi mabadiliko katika mwangaza wa LED; kwenye oscilloscope iliyounganishwa unaweza kuona jinsi ishara kutoka kwa Arduino inavyobadilika.

    Urekebishaji wa upana wa mapigo (PWM) ya Arduino UNO na NANO hufanya kazi kwenye matokeo ya analogi 3, 5, 6, 9, 10, 11 na mzunguko wa 488.28 Hz. Kwa kutumia kazi ya AnalogWrite, mzunguko wa PWM hutofautiana kutoka 0 hadi 255 na inalingana na mzunguko wa mzunguko wa mzunguko wa pulse kutoka 0 hadi 100%. Kwa vifaa vingi, mzunguko wa Arduino NANO PWM ni mdogo sana, kwa hiyo inahitaji kuongezeka. Hebu tuangalie jinsi ya kufanya hivyo kwa usahihi.

    Arduino Pulse Width Modulation

    PWM, kwa Kiingereza Pulse-Width Modulation (PWM) ni udhibiti wa nguvu kwenye mzigo kwa kubadilisha mzunguko wa wajibu (upana) wa mapigo kwa mzunguko wa mara kwa mara na amplitude ya ishara. Grafu ifuatayo inaonyesha kuwa kwa maadili tofauti katika kazi ya AnalogWrite, amplitude ya mapigo inabaki mara kwa mara, lakini upana wa mapigo hubadilika. Nguvu ya ishara huamua mzunguko wa wajibu wa pigo.

    Ratiba. Vigezo vya ishara, mzunguko wa wajibu wa PWM

    Kuna maeneo mawili ya utumiaji wa moduli ya upana wa mapigo:

    1. PWM hutumiwa katika vifaa vya nguvu, vidhibiti vya nguvu, nk. Matumizi ya PWM kwenye Arduino Nano inafanya uwezekano wa kurahisisha kwa kiasi kikubwa udhibiti wa mwangaza wa vyanzo vya mwanga (LED, vipande vya LED) na kasi ya mzunguko wa motors.

    2. PWM hutumiwa kupokea ishara ya analog. Kigeuzi cha digital-to-analog (DAC) kwenye Arduino ni rahisi kutekeleza, kwani inahitaji kiwango cha chini cha vipengele vya redio - mlolongo mmoja tu wa RC wa kupinga na capacitor ni wa kutosha.

    Kubadilisha frequency ya Arduino PWM (saizi kidogo)

    Bodi za Arduino Uno na Arduino Nano kulingana na ATmega168/328 zina vidhibiti 6 vya PWM kwenye bandari za analogi 3, 5, 6, 9, 10, 11. Ishara ya PWM inadhibitiwa kwa kutumia kazi ya AnalogWrite, ambayo hutoa ishara ya analog kwenye pato na huweka msukumo wa mzunguko wa wajibu. Arduino huweka mzunguko wa pini hadi 488.28 Hz na azimio kwa bits 8 (kutoka 0 hadi 255).


    Mpango. Urekebishaji wa upana wa mapigo kwa dummies

    Arduino kulingana na ATmega168/328 hutumia vipima muda vitatu kwa PWM:

    Kipima muda 0- hitimisho 5 na 6
    Kipima muda 1- hitimisho 9 na 10
    Kipima muda 2- hitimisho 3 na 11

    Arduino PWM imedhamiriwa na vipengele vilivyounganishwa vinavyoitwa vipima muda. Kila timer katika Arduino Uno na Nano bodi kulingana na ATmega168/328 microcontroller ina njia mbili kushikamana na matokeo. Ili kubadilisha mzunguko wa ishara ya PWM, unahitaji kubadilisha timer ambayo imeunganishwa. Katika kesi hii, PWM pia itabadilika kwenye matokeo ya analog yaliyounganishwa kwa sambamba na timer sawa.

    Jinsi ya kuongeza frequency na kina kidogo cha Arduino PWM

    Hakuna njia ya kubadilisha mzunguko wa Arduino PWM bila kusimamia kumbukumbu moja kwa moja kwa kiwango cha chini. Hebu tuangalie zaidi jinsi ya kubadilisha mode ya uendeshaji wa timer ili kuongeza mzunguko wa Arduino PWM. Kipima muda 0 kutumika kuhesabu wakati, i.e. kuchelewesha na kazi za millis. Kuongeza marudio kwenye Timer 0 kutavunja vitendaji vya kuokoa muda ambavyo vinaweza kutumika kwenye mchoro.

    Ili kuongeza uwezo wa kidogo wa Arduino kwenye matokeo ya analog 9 na 10, badilisha mzunguko Kipima muda 1 bila maktaba. Masafa ya juu ya PWM yanaweza kufikia 62,500 Hz kwenye mbao za Arduino Uno na Nano. Ili kufanya hivyo, katika usanidi wa utupu () utaratibu, unahitaji kuongeza amri inayofaa kutoka kwa jedwali hapa chini.

    Ruhusa Mzunguko wa PWM Amri za kuweka modi
    8 kidogo 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;

    Kiwango cha juu cha mzunguko wa Arduino PWM ni 62,500 Hz.



    MAKALA INAYOHUSIANA