Arduino प्रकल्प. अर्डिनोचे धडे, प्रोग्रामिंग, नियंत्रण आणि कनेक्शन. Arduino आणि RGB LED च्या उबदार कंपनीमध्ये PWM मास्टरिंग

शक्यता 14.07.2019

शक्यता

सुमारे 3 महिन्यांपूर्वी, बऱ्याच दुर्दैवी इलेक्ट्रॉनिक्स प्रमाणे, मी स्वतः खरेदी केले, माझ्या मते, त्या वेळी, Arduino कुटुंबातील सर्वात अत्याधुनिक मायक्रोप्रोसेसर बोर्ड, म्हणजे Seeduino Mega, Atmega1280 प्रोसेसरवर आधारित. फिरत असलेल्या सर्वो ड्राइव्ह आणि ब्लिंकिंग LED सह माझ्या मनातील सामग्रीचे लाड केल्यानंतर, प्रश्न उद्भवला: "मी ते का विकत घेतले?"

मी झेलेनोग्राडमधील मोठ्या लष्करी प्लांटमध्ये आघाडीच्या डिझायनरपैकी एक म्हणून काम करतो आणि सध्या मेट्रोलॉजिकल मापन यंत्र विकसित करण्याच्या प्रकल्पाचे नेतृत्व करत आहे. या कार्यामध्ये असंख्य समस्या आहेत ज्यासाठी वैयक्तिक निराकरण आवश्यक आहे. यापैकी एक कार्य म्हणजे स्टेपर मोटरला आवाज न करता आणि 1.8 डिग्रीच्या पायऱ्यांमध्ये, स्टेपर मोटर डॉक्युमेंटेशनमध्ये सांगितल्याप्रमाणे, परंतु 0.0001 डिग्री पर्यंत नियंत्रित करणे. असे दिसते की समस्या जटिल आणि निराकरण करण्यायोग्य नाही, परंतु नियंत्रण सर्किट्ससह थोडेसे टिंकर केल्यानंतर, मी निष्कर्षापर्यंत पोहोचलो की सर्वकाही वास्तविक आणि शक्य आहे. यासाठी फक्त एका विशिष्ट आकाराचे दोन सिग्नल तयार करणे आणि फेज शिफ्ट आणि 1 मेगाहर्ट्झ पर्यंत व्होल्टेज बदलण्याची वारंवारता आवश्यक आहे. (मी स्टेपर मोटरचा तपशीलवार अभ्यास लिहीन आणि पुढील लेखात नियंत्रणाची सर्व रहस्ये उघड करेन) लगेचच, माझ्या डोक्यात आशेची किरणे दिसू लागली की मी माझ्या छोट्या लाल सीडुइनोवर 1,500 रूबल व्यर्थ खर्च केले नाहीत, आणि मी, उत्साह वाढवत, ते शोधू लागलो.

प्रारंभिक भयपट:

मायक्रोप्रोसेसर बोर्ड ऑसिलोस्कोपशी कनेक्ट केल्यावर, आणि डिजिटलराईट(HIGH) सायकल लिहिताना, आणि DigitalWrite(LOW) च्या खाली, मला ऑसिलोस्कोपवर 50Hz ची वारंवारता असलेली एक निस्तेज स्क्वेअर वेव्ह आढळली. एक भयानक स्वप्न. हे एक संकुचित आहे, मला वाटले, आवश्यक 1 मेगाहर्ट्झच्या पार्श्वभूमीवर.
पुढे, ऑसिलोस्कोपद्वारे, मी आणखी अनेक अंमलबजावणी गतींचा अभ्यास केला:
AnalogRead() - अंमलबजावणी गती 110 µs.
AnalogWrite() - 2000 µs
SerialPrintLn() - वेगाने 9600 सुमारे 250 µs, आणि कमाल वेगाने सुमारे 3 µs.
DigitalWrite() - 1800µs
DigitalRead() - 1900µs

यावेळी, मला अश्रू अनावर झाले आणि माझा सीडुइनो जवळजवळ फेकून दिला. पण ते तिथे नव्हते!

आपण प्रयत्न करेपर्यंत आपण काय करू शकता हे आपल्याला कधीच कळत नाही!

मी तुम्हाला माझ्या मानसिक त्रासाबद्दल सांगणार नाही आणि तीन दिवसांच्या अभ्यासाचे वर्णन करणार नाही, सर्वकाही जसे आहे तसे सांगणे चांगले आहे!
Arduino आणि Atmega1280 प्रोसेसरवरील सर्व संभाव्य दस्तऐवज पाहिल्यानंतर आणि परदेशी सहकाऱ्यांच्या अनुभवावर संशोधन केल्यावर, मी वाचन/लिहणे कसे बदलायचे याबद्दल काही टिप्स देऊ इच्छितो:

AnalogRead() सुधारत आहे

#FASTADC 1 परिभाषित करा

// नोंदणी बिट्स सेट करणे आणि साफ करणे यासाठी परिभाषित करते
#ifndef cbi
# cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit)) परिभाषित करा
#endif
#ifndef sbi
#sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit)) परिभाषित करा
#endif

शून्य सेटअप() (
int प्रारंभ;
int i ;

#if FASTADC
// प्रीस्केल 16 वर सेट करा
sbi(ADCSRA,ADPS2);
cbi(ADCSRA,ADPS1);
cbi(ADCSRA,ADPS0);
#endif

Serial.begin(9600);
Serial.print("ADCTEST:");
प्रारंभ = मिलिस();
साठी (i = 0; i< 30000 ; i++)
analogRead(0);
Serial.print(millis() - start);
Serial.println("msec (30000 कॉल)" ;
}

शून्य लूप() (
}

परिणाम: वेग 18.2 µs exes विरुद्ध 110 µs.
तसे, Atmega ADC ची कमाल गती फक्त 16 मायक्रोसेकंद आहे. एक पर्याय म्हणजे दुसरे मायक्रोसर्कीट वापरणे, जे विशेषतः एडीसीसाठी तयार केले गेले आहे, ज्यामुळे वेग कमी होईल 0.2µs(खाली वाचा का)

डिजिटल राइट () सुधारत आहे

प्रत्येक Arduino/Seeduino/Feduino/Orduino/otherduino मध्ये पोर्ट असतात. प्रत्येक पोर्ट 8 बिट्स आहे, जे प्रथम रेकॉर्डिंगसाठी कॉन्फिगर केले जाणे आवश्यक आहे. उदाहरणार्थ, माझ्या Seeeduino PORTA वर - 22 ते 30 पायांपर्यंत. आता सर्वकाही सोपे आहे. आम्ही फंक्शन्स वापरून पाय 22 ते 30 नियंत्रित करतो
PORTA=B00001010 (बिट, पाय 23 आणि 25 - उच्च)
किंवा
PORTA=10 (दशांश, अजूनही समान)
परिणाम =0.2µsविरुद्ध 1800us, जे सामान्य digitalWrite() द्वारे प्राप्त केले जातात

डिजिटल रीड () सुधारत आहे

डिजीटल राइट() च्या सुधारणे प्रमाणेच, परंतु आता आम्ही पाय INPUT वर सेट करतो आणि वापरतो, उदाहरणार्थ:
जर (PINA==B00000010) (...) (जर लेग 23 वर HIGH असेल आणि लेग 22 आणि 24-30 वर LOW असेल)
परिणामहे करत असल्यास () - 0.2µsविरुद्ध 1900µs, जे नेहमीच्या digitalRead() द्वारे प्राप्त केले जाते.

PWM मॉड्युलेटर सुधारणे, किंवा analogWrite()

तर, असा पुरावा आहे की digitalRead() 0.2 µs मध्ये कार्यान्वित होते, आणि PWM मॉड्युलेटरचे रिझोल्यूशन 8 बिट आहे, किमान PWM स्विचिंग वेळ 51.2 µs विरुद्ध 2000 µs आहे.
आम्ही खालील कोड वापरतो:
int PWM_time=32; // आम्हाला analogWrite वर लिहायचा आहे तो नंबर (PIN, 32)
साठी (int k=0;k साठी (int k=0;k<256-PWM_time) PORTA=B00000000;

त्यामुळे आम्हाला ते मिळालेवारंवारता सह PWM 19kHzविरुद्ध 50 Hz

चला सारांश द्या

digitalWrite() होते 1800us, ते झाले 0.2µs
digitalRead() होते 1900µs, ते झाले 0.2µs
analogWrite() होते 2000us, ते झाले 51.2µs
analogRead() होते 110µs, ते झाले 18.2µs, किंवा कदाचित पर्यंत 0.2µs

आणि एक नवीन कार्य पूर्ण करण्याचा प्रयत्न करूया. मला वाटते की प्रत्येकाने नवीन वर्षाचे प्रदर्शन हार पाहिले आहेत ज्यामध्ये एलईडी सहजतेने लुकलुकतात. आपण असे काहीतरी करू इच्छितो असे म्हणूया.
आम्ही डिजीटल राइट() फंक्शन आधीच पाहिले आहे आणि माहित आहे की ते लिहिते मूल्य दोन पर्याय असू शकतात - उच्च किंवा कमी. या प्रकरणात, analogWrite() फंक्शन आम्हाला मदत करेल. फंक्शन्सचे "फॉर्म्युलेशन" फक्त प्रारंभिक उपसर्गांमध्ये भिन्न असतात, म्हणून ते लक्षात ठेवणे सोपे आहे.

analogWrite() फंक्शन, जसे digitalWrite(), कंसात दोन आर्ग्युमेंट्स असतात आणि त्याच मौखिक तत्त्वावर कार्य करतात: “कुठे, काय”. मुख्य फरक म्हणजे नेहमीच्या कमी किंवा उच्च ऐवजी विस्तृत मूल्ये रेकॉर्ड करण्याची क्षमता. हे आम्हाला एलईडीची चमक समायोजित करण्यास अनुमती देईल. लक्षात ठेवण्यासाठी मुख्य टीप म्हणजे हे वैशिष्ट्य केवळ काही विशिष्ट संपर्कांवर कार्य करते. या पिन "~" चिन्हाने चिन्हांकित आहेत. हे चिन्ह सूचित करते की हा PWM संपर्क आहे. PWM (पल्स-रुंदी मॉड्युलेशन) रशियनमध्ये PWM (पल्स-रुंदी मॉड्युलेशन) सारखे ध्वनी. ऑपरेटिंग तत्त्व पल्स कालावधी बदलण्यावर आधारित आहे. ग्राफिकदृष्ट्या हे असे चित्रित केले जाऊ शकते:

एक साधे उदाहरण पाहून हे कसे कार्य करते हे शोधण्याचा प्रयत्न करूया. हे करण्यासाठी, तुम्हाला LED ला PWM संपर्काशी 150 Ohm रोधक आणि "हार्डवायर" एक साधा प्रोग्राम Arduino मध्ये जोडणे आवश्यक आहे. कनेक्शन आकृती आणि स्केच कोड खाली सादर केला आहे:

निरर्थक सेटअप()
{
पिनमोड (लेड, आउटपुट);
}
शून्य पळवाट()
{
साठी(int i=0; i<=255; i++)
{
analogWrite(led,i);
विलंब(10);
}
साठी(int i=255; i>=0; i--)
{
analogWrite(led,i);
विलंब(10);
}
}

मला वाटते की कोड सामान्यतः स्पष्ट आहे, परंतु आम्हाला for() लूपकडे थोडे लक्ष देणे आवश्यक आहे. परवानगी अशी एक गोष्ट आहे. आम्ही 8-बिट रिझोल्यूशनसह कार्य करत असल्याने (यावर थोड्या वेळाने चर्चा केली जाईल), किमान मूल्य 0 असेल आणि कमाल 255 असेल. प्रत्येक पुनरावृत्तीच्या शेवटी, आम्ही वेळ विलंब 10ms वर सेट करतो.

मागील धड्यातील आकृतीकडे परत जाऊ आणि analogWrite() फंक्शन वापरून एक समान माला बनवण्याचा प्रयत्न करू.

int buttonPin = 2;
int पिन = (3,5,6,9,10,11);
बुलियन लास्ट बटन = कमी;
बुलियन करंट बटन = कमी;
boolean enable = असत्य;
निरर्थक सेटअप()
{
पिनमोड(बटणपिन, इनपुट);
साठी(इंट मोड = 0; मोड<= 5; mode++) pinMode(pins, OUTPUT);
}
बुलियन डिबाउन्स (बुलियन शेवटचे)
{
बुलियन करंट = डिजिटल रीड(बटणपिन);
जर (अंतिम ! = वर्तमान)
{
विलंब(5);
चालू = डिजिटल रीड(बटणपिन);
}
रिटर्न करंट;
}
शून्य पळवाट()
{
currentButton = debounce(अंतिम बटण);
जर (अंतिम बटण == कमी आणि चालू बटण == उच्च)
{
सक्षम = !सक्षम करा;
}
जर (सक्षम == खरे)
{
साठी (int i=0; i<=5; i++)
{
साठी (इंट ब्राइटनेस = 0; ब्राइटनेस<= 255; brightness++)
{
विलंब(1);
}
विलंब(40);
}
साठी (int i=0; i<=5; i++)
{
साठी (इंट ब्राइटनेस = 255; ब्राइटनेस >= 0; ब्राइटनेस--)
{
analogWrite(पिन[i], ब्राइटनेस);
विलंब(1);
}
विलंब(40);
}
}
जर (सक्षम == असत्य)
{
साठी(int i = 0; i<= 5; i++) digitalWrite(pins[i], LOW);
}
LastButton = currentButton;
}

दृश्यमानपणे स्केच काहीसे अधिक जटिल झाले आहे. खरं तर, येथे सर्वकाही सोपे आहे आणि चला ते शोधूया. आम्हाला सर्व कनेक्टेड LEDs ओळखण्याची गरज आहे, परंतु नेहमीच्या int led ऐवजी आम्ही ॲरे वापरतो, ज्यातील प्रत्येक घटक Arduino वर PWM पिन आहे. व्हॉइड सेटअप() फंक्शनच्या मुख्य भागामध्ये, आम्ही धूर्त पद्धतीने काम केले. आम्ही सर्व संपर्कांची “सूची” for() लूपवर सोपवली आहे, ज्याच्या प्रत्येक पुनरावृत्तीसह संबंधित संपर्क OUTPUT वर कॉन्फिगर केला आहे. void loop() फंक्शन वर जाऊ. debounce() फंक्शन आणि प्रारंभिक if() कंडिशन अपरिवर्तित राहते. आम्ही अजूनही दोन व्हेरिएबल्सचे स्तर तपासत आहोत: मागील मूल्य (सुरुवातीला कमी) आणि बटणाची वर्तमान स्थिती. या अटी पूर्ण झाल्यावर, सक्षम व्हेरिएबलचे मूल्य उलटे केले जाते. हे लक्षात घेऊन, आम्ही आणखी दोन सोप्या if() अटी जोडल्या आहेत. सक्षम = सत्य असल्यास, माला चालू केली जाते, त्यातील "वाहते" ची गुळगुळीतता for() लूपद्वारे नियंत्रित केली जाते. सक्षम = असत्य असल्यास, सर्व LEDs बंद आहेत. अटींच्या शेवटी, शेवटचे बटण व्हेरिएबल बटणाची वर्तमान स्थिती घेते.
आमच्या प्रोग्रामची चाचणी करताना, आम्हाला असे आढळले की सर्वकाही अपेक्षेप्रमाणे कार्य करत नाही. लक्षात ठेवा, शेवटच्या धड्यात आम्ही एक दुरुस्ती केली आहे की जर वेळ विलंब मोठा असेल, तर बटण कालबाह्य झाल्यानंतर फायर होईल? मागील उदाहरणामध्ये, जेव्हा माला चालू होती, तेव्हा व्हॉइड लूप() फंक्शनच्या मुख्य भागामध्ये एकूण विलंब 85ms होता. यामुळे आम्हाला ठराविक कालावधीत "तेथे पोहोचण्याची" संधी मिळाली. या स्केचमध्ये, त्याच स्थितीत, विलंब अनेक वेळा भिन्न आहे. कदाचित, जर तुम्हाला माला बंद करायची असेल तर "व्यत्यय" हा शब्द स्वतःच सूचित करतो. हा असेल या समस्येवर उपाय!

मला आशा आहे की हा लेख आपल्यासाठी उपयुक्त होता. पुढील ट्युटोरियलमध्ये आपण Arduino मधील व्यत्यय पाहू आणि इच्छित परिणाम प्राप्त करू.

निरर्थक सेटअप()
{
पिनमोड (लेड, आउटपुट);
}
शून्य पळवाट()
{
साठी(int i=0; i<=255; i++)
{
analogWrite(led,i);
विलंब(10);
}
साठी(int i=255; i>=0; i--)
{
analogWrite(led,i);
विलंब(10);
}
}

int buttonPin = 2;
int पिन = (3,5,6,9,10,11);
बुलियन लास्ट बटन = कमी;
बुलियन करंट बटन = कमी;
boolean enable = असत्य;
निरर्थक सेटअप()
{
पिनमोड(बटणपिन, इनपुट);
साठी(इंट मोड = 0; मोड<= 5; mode++) pinMode(pins, OUTPUT);
}
बुलियन डिबाउन्स (बुलियन शेवटचे)
{
बुलियन करंट = डिजिटल रीड(बटणपिन);
जर (अंतिम ! = वर्तमान)
{
विलंब(5);
चालू = डिजिटल रीड(बटणपिन);
}
रिटर्न करंट;
}
शून्य पळवाट()
{
currentButton = debounce(अंतिम बटण);
जर (अंतिम बटण == कमी आणि चालू बटण == उच्च)
{
सक्षम = !सक्षम करा;
}
जर (सक्षम == खरे)
{
साठी (int i=0; i<=5; i++)
{
साठी (इंट ब्राइटनेस = 0; ब्राइटनेस<= 255; brightness++)
{
विलंब(1);
}
विलंब(40);
}
साठी (int i=0; i<=5; i++)
{
साठी (इंट ब्राइटनेस = 255; ब्राइटनेस >= 0; ब्राइटनेस--)
{
analogWrite(पिन[i], ब्राइटनेस);
विलंब(1);
}
विलंब(40);
}
}
जर (सक्षम == असत्य)
{
साठी(int i = 0; i<= 5; i++) digitalWrite(pins[i], LOW);
}
LastButton = currentButton;
}

पल्स विड्थ मॉड्युलेशन (PWM) मजेदार आहे आणि विशेषत: सर्वो नियंत्रित करण्यासाठी वापरण्यासाठी मजेदार आहे, परंतु आज आम्ही ते तीन-रंगाच्या एलईडीवर लागू करू. हे आपल्याला त्याच्या रंगावर नियंत्रण ठेवण्यास आणि सौंदर्याचे काही प्रतीक प्राप्त करण्यास अनुमती देईल.

PWM

PWM ची व्याख्या विकिपीडियामध्ये कल्पकतेने तयार केली गेली आहे, म्हणून मी तेथून कॉपी करेन: "पीडब्ल्यूएम - वास्तविक बायनरी सिग्नल (दोन स्तरांसह -) इच्छित सिग्नलचे अंदाजे (बहु-स्तरीय किंवा सतत)चालु बंद ), जेणेकरून, सरासरी, विशिष्ट कालावधीत, त्यांची मूल्ये समान असतील. <...> शे IM हा स्थिर वारंवारता आणि चलचा पल्स सिग्नल आहेकार्यकालचक्र , म्हणजे, नाडी पुनरावृत्ती कालावधी आणि त्याच्या कालावधीचे गुणोत्तर. कर्तव्य चक्र (पल्स कालावधी) सेट करूनतुम्ही PWM आउटपुटवर सरासरी व्होल्टेज बदलू शकता. "

आता याचा अर्थ काय ते समजून घेऊ. यासारखे एक सामान्य आयताकृती सिग्नल असू द्या:

त्याची निश्चित वारंवारता आणि 50% कर्तव्य चक्र आहे. याचा अर्थ असा की अर्ध्या कालावधीत व्होल्टेज कमाल असते आणि उर्वरित अर्धा ते शून्य असते. या कालावधीत हे सिग्नल एकत्रित केल्यावर, आम्ही पाहतो की त्याची उर्जा जास्तीत जास्त निम्म्या इतकी आहे. हे समतुल्य असेल जर आम्ही सर्व वेळअर्धा व्होल्टेज लागू झाला.

जर आमचा कमाल व्होल्टेज 5 V असेल, तर PWM आउटपुटवर मिळणारा व्होल्टेज 5 V ने गुणाकार केलेल्या ड्युटी सायकलच्या बरोबरीचा असतो (आणि 100% ने भागलेला असतो जेणेकरून फॉर्मल-नाझी जोडले जाणार नाहीत):

Arduino तुम्हाला PWM आउटपुटवर 0 ते 255 पर्यंत मूल्य लिहिण्याची परवानगी देतो, याचा अर्थ असा की आम्हाला अंदाजे 20 mV च्या रिझोल्यूशनसह व्होल्टेज मिळू शकते.

तिरंगी एलईडी

हा आहे, चार पायांचा देखणा माणूस:

सर्वात लांब पाय सामान्य एनोड आहे, आणि बाकीचे सर्व कॅथोड आहेत, प्रत्येक त्याच्या स्वतःच्या रंगासाठी जबाबदार आहे: (चित्र पहा) तळाचा एक लाल आहे, दुसरा वरून हिरवा आहे, वरचा एक निळा आहे.

तुम्ही लांब पायाला +5V आणि इतर सर्वांसाठी 0V लावल्यास, तुम्हाला पांढरा प्रकाश मिळेल (मी तुम्हाला विनंती करतो, स्वतःचे संरक्षण करा - मर्यादित प्रतिरोधक स्थापित करा!). ते किती पांढरे आहे हे खालील व्हिडिओद्वारे ठरवले जाऊ शकते:

परंतु त्यावर पांढरा रंग मिळणे मनोरंजक नाही. चला तर मग बघूया ते वेगवेगळ्या रंगात कसे चमकवायचे.

Arduino वर PWM

Arduino वर PWM वारंवारता अंदाजे 490 Hz आहे. Arduino UNO बोर्डवर, PWM साठी वापरल्या जाणाऱ्या पिन 3,5,6, 9, 10 आणि 11 आहेत. यासाठी बोर्डवर एक इशारा आहे - PWM पिन नंबरच्या आधी सिल्कस्क्रीनमध्ये टिल्ड किंवा तीक्ष्ण आहे. .

Arduino वर PWM नियंत्रित करण्यापेक्षा काहीही सोपे नाही! हे करण्यासाठी, एकच फंक्शन वापरा analogWrite(पिन, मूल्य), कुठे पिन- पिन नंबर आणि मूल्य- 0 ते 255 पर्यंतचे मूल्य. या प्रकरणात, तुम्हाला काहीही लिहिण्याची गरज नाही निरर्थक सेटअप()!

आपण याबद्दल अधिक इंग्रजीमध्ये वाचू शकता आणि.

आम्ही थोडे काम करतो

चला विविध रंगांमध्ये एलईडी शिमर बनवूया. एक रंग फिका पडू द्या तर दुसरा भडकू द्या. आम्ही दोन रंगांना पर्यायी करू, आणि रंग एका वर्तुळात लाल ते हिरव्या, हिरव्यापासून निळ्या, निळ्यापासून लाल रंगात फिरेल.

चला एक साधा आकृती एकत्र ठेवूया:

आणि चला काही सोपा कोड लिहू:

// रंगानुसार पिनला नाव द्या
int REDpin = 9;
int GREENpin = 10;
int BLUEpin = 11;

शून्य सेटअप (){}

शून्य पळवाट (){
साठी (इंट मूल्य = 0; मूल्य<= 255; value +=1) {
// लाल चमक कमी होते
analogWrite(REDpin, value);
//हिरव्या चमक वाढते
analogWrite(ग्रीनपिन, 255-मूल्य);
// निळा बंद आहे
analogWrite(ब्लूपिन, 255);
//विराम द्या
विलंब(३०);
}

साठी (इंट मूल्य = 0; मूल्य<= 255; value +=1) {
// लाल बंद आहे
analogWrite(REDpin, 255);
//हिरव्या चमक कमी होते
analogWrite(ग्रीनपिन, मूल्य);
// निळा चमक वाढतो
analogWrite(ब्लूपिन, 255-मूल्य);
//विराम द्या
विलंब(३०);
}

साठी (इंट मूल्य = 0; मूल्य<= 255; value +=1) {
// लाल चमक वाढते
analogWrite(REDpin, 255-value);
//हिरवा बंद आहे
analogWrite(ग्रीनपिन, 255);
// निळा चमक कमी होतो
analogWrite(ब्लूपिन, मूल्य);
//विराम द्या
विलंब(३०);
}
}

Arduino UNO आणि NANO चे पल्स विड्थ मॉड्युलेशन (PWM) 488.28 Hz च्या वारंवारतेसह ॲनालॉग आउटपुट 3, 5, 6, 9, 10, 11 वर चालते. analogWrite फंक्शन वापरून, PWM वारंवारता 0 ते 255 पर्यंत बदलते आणि 0 ते 100% पर्यंत पल्स ड्यूटी सायकलशी संबंधित असते. अनेक उपकरणांसाठी, Arduino NANO PWM वारंवारता खूप कमी आहे, म्हणून ती वाढवणे आवश्यक आहे. हे योग्यरित्या कसे करायचे ते पाहूया.

Arduino पल्स रुंदी मॉड्यूलेशन

PWM, इंग्रजीमध्ये पल्स-विड्थ मॉड्युलेशन (PWM) म्हणजे सिग्नलच्या स्थिर वारंवारता आणि मोठेपणावर डाळींचे कर्तव्य चक्र (रुंदी) बदलून लोडवरील शक्तीचे नियंत्रण. खालील आलेख दाखवतो की analogWrite फंक्शनमधील भिन्न मूल्यांसाठी, डाळींचे मोठेपणा स्थिर राहते, परंतु डाळींची रुंदी बदलते. सिग्नल पॉवर नाडीचे कर्तव्य चक्र निर्धारित करते.

वेळापत्रक. सिग्नल पॅरामीटर्स, PWM ड्यूटी सायकल

पल्स रुंदी मॉड्यूलेशन लागू करण्याची दोन क्षेत्रे आहेत:

1. PWM वीज पुरवठा, पॉवर रेग्युलेटर इ. मध्ये वापरला जातो. Arduino Nano वर PWM चा वापर प्रकाश स्रोतांच्या (LEDs, LED पट्ट्या) ब्राइटनेस आणि मोटर्सच्या रोटेशन गतीचे नियंत्रण लक्षणीयरीत्या सुलभ करणे शक्य करते.

2. एनालॉग सिग्नल प्राप्त करण्यासाठी PWM चा वापर केला जातो. Arduino वर डिजिटल-टू-एनालॉग कन्व्हर्टर (DAC) लागू करणे सोपे आहे, कारण त्यासाठी किमान रेडिओ घटक आवश्यक आहेत - रेझिस्टर आणि कॅपेसिटरची फक्त एक RC चेन पुरेसे आहे.

Arduino PWM वारंवारता बदलणे (बिट आकार)

ATmega168/328 वर आधारित Arduino Uno आणि Arduino Nano बोर्ड्समध्ये analog पोर्ट्स 3, 5, 6, 9, 10, 11 वर 6 हार्डवेअर PWM मॉड्युलेटर आहेत. PWM सिग्नल analogWrite फंक्शन वापरून नियंत्रित केला जातो, जो ॲनालॉग सिग्नल व आउटपुट सिग्नल तयार करतो. कर्तव्य चक्र आवेग सेट करते. Arduino पिन वारंवारता 488.28 Hz आणि रिझोल्यूशन 8 बिट (0 ते 255 पर्यंत) वर सेट करते.

योजना. डमीसाठी पल्स रुंदी मॉड्यूलेशन

ATmega168/328 वर आधारित Arduino PWM साठी तीन टाइमर वापरते:

टाइमर ०— निष्कर्ष ५ आणि ६
टाइमर १— निष्कर्ष 9 आणि 10
टाइमर 2— निष्कर्ष 3 आणि 11

Arduino PWM टाइमर नावाच्या एकात्मिक घटकांद्वारे निर्धारित केले जाते. ATmega168/328 मायक्रोकंट्रोलरवर आधारित Arduino Uno आणि Nano बोर्डमधील प्रत्येक टाइमरमध्ये दोन चॅनेल आउटपुटशी जोडलेले असतात. PWM सिग्नलची वारंवारता बदलण्यासाठी, तुम्हाला तो कनेक्ट केलेला टायमर बदलण्याची आवश्यकता आहे. या प्रकरणात, PWM समान टाइमरच्या समांतर कनेक्ट केलेल्या ॲनालॉग आउटपुटवर देखील बदलेल.

Arduino PWM ची वारंवारता आणि बिट खोली कशी वाढवायची

कमी स्तरावर मेमरी थेट व्यवस्थापित केल्याशिवाय Arduino PWM वारंवारता बदलण्याचा कोणताही मार्ग नाही. Arduino PWM वारंवारता वाढवण्यासाठी टाइमर ऑपरेटिंग मोड कसा बदलायचा ते पाहू. टाइमर ०वेळ मोजण्यासाठी वापरले जाते, म्हणजे विलंब आणि मिलिस कार्ये. टाइमर 0 वर वारंवारता वाढवल्याने स्केचमध्ये वापरल्या जाणाऱ्या वेळ-बचत कार्ये खंडित होतील.

ॲनालॉग आउटपुट 9 आणि 10 वर Arduino बिट क्षमता वाढवण्यासाठी, वारंवारता बदला टाइमर १लायब्ररीशिवाय. Arduino Uno आणि Nano बोर्डांवर PWM वारंवारता 62,500 Hz पर्यंत पोहोचू शकते. हे करण्यासाठी, void setup() प्रक्रियेमध्ये तुम्हाला खालील तक्त्यामधून योग्य कमांड जोडण्याची आवश्यकता आहे.

परवानगी	PWM वारंवारता	मोड सेटिंग आदेश
8 बिट	62,500 Hz	TCCR1A = TCCR1A आणि 0xe0 \| 1; TCCR1B = TCCR1B आणि 0xe0 \| 0x09;
	७,८१२.५ हर्ट्झ	TCCR1A = TCCR1A आणि 0xe0 \| 1; TCCR1B = TCCR1B आणि 0xe0 \| 0x0a;
	९७६.५६ हर्ट्झ	TCCR1A = TCCR1A आणि 0xe0 \| 1; TCCR1B = TCCR1B आणि 0xe0 \| 0x0b;
	244.14 Hz	TCCR1A = TCCR1A आणि 0xe0 \| 1; TCCR1B = TCCR1B आणि 0xe0 \| 0x0c;
	६१.०४ हर्ट्झ	TCCR1A = TCCR1A आणि 0xe0 \| 1; TCCR1B = TCCR1B आणि 0xe0 \| 0x0d;