PWM का उपयोग करते समय एल ई डी में गैर-रैखिक चमक के लिए सही


33

पीडब्लूएम के साथ एक एलईडी ड्राइविंग करते समय, चमक (जैसा कि मुझे लगता है) कर्तव्य चक्र के साथ रैखिक पैमाने पर नहीं होता है। चमक रैंप के लिए धीमी है, फिर कर्तव्य चक्र के साथ तेजी से बढ़ता है।

क्या कोई एक सुधार कारक, या अन्य समाधान के रूप में उपयोग करने के लिए अंगूठे के नियम का सुझाव दे सकता है?


जब मैंने नाइट राइडर कफ लिंक की एक जोड़ी बनाई, तो मुझे फीका लगने के लिए x ^ 10 का उपयोग करना पड़ा!
राकेटमग्नेट

3
क्या आप सुनिश्चित हैं कि यह "चमक शुरू में तेजी से बढ़ता है, और फिर रैंप पर धीमा है"?
दिमित्री ग्रिगोरीव

1
मेरा मानना ​​है कि हमारी आँखें चमक के लिए तार्किक रूप से प्रतिक्रिया करती हैं।
DKNguyen

जवाबों:


13

16 स्तरों के लिए एक साधारण लुक-अप टेबल "हाथ से" करना आसान है और पीडब्लूएम नियंत्रक को पास करने के लिए 8 बिट मान में 4 बिट मूल्य को परिवर्तित करें: यह वह घटक है जिसका उपयोग मैंने अपने FPGA के नेतृत्व वाले सरणी ड्राइवर में किया है। 8 बिट लेवल कंट्रोलर के लिए, आपको लुक-अप टेबल से कम से कम 11-12 बिट आउटपुट की आवश्यकता होगी।

library IEEE;
use IEEE.Std_logic_1164.all;

entity Linearize is
port ( reqlev : in std_logic_vector (3 downto 0) ;
    pwmdrive : out std_logic_vector (7 downto 0) );
    end Linearize;

architecture LUT of Linearize is
    begin
    with reqlev select
        pwmdrive <= "00000000" when "0000",
                    "00000010" when "0001",
                    "00000100" when "0010",
                    "00000111" when "0011",
                    "00001011" when "0100",
                    "00010010" when "0101",
                    "00011110" when "0110",
                    "00101000" when "0111",
                    "00110010" when "1000",
                    "01000001" when "1001",
                    "01010000" when "1010",
                    "01100100" when "1011",
                    "01111101" when "1100",
                    "10100000" when "1101",
                    "11001000" when "1110",
                    "11111111" when "1111",
                    "00000000" when others;
    end LUT;

मैं यह जानने की कोशिश कर रहा हूं कि आपका फॉर्मूला क्या है। यह उल्लेखनीय रूप से f (x) = x ^ 2 के करीब है, लेकिन वक्र काफी गहरा नहीं है। f (x) = x ^ 3/13 मुझे बहुत करीब आता है।
ajs410 19

यह कोई फॉर्मूला नहीं है (जानबूझकर नहीं) ... मैंने लाइनराइज़र प्रारंभिक मानों में सिर्फ अनुमान लगाया है कि :-)। मैंने तब सरणी संचालित की है, जो चमकते क्रम में स्तंभों का नेतृत्व कर रहा है, और एक समान रैंप प्राप्त करने के लिए मूल्यों को बदल दिया है। यह केवल 16 स्तरों के साथ वास्तव में आसान है।
एक्समैन

1
2n1

17

सिद्धांत रूप में यह घातीय होना चाहिए, लेकिन मुझे द्विघात फ़ंक्शन का उपयोग करके लुप्त होती के लिए सबसे अच्छा परिणाम मिला है।

मुझे भी लगता है कि आपको यह पीछे की ओर मिला। कम कर्तव्य चक्र में चमक में कथित वृद्धि लगभग पूर्ण कर्तव्य चक्र की तुलना में बहुत बड़ी है, जहां चमक में वृद्धि लगभग असंभव है।



17

मैं पिछले कुछ दिनों से इस विषय को देख रहा हूं क्योंकि मुझे भी यही समस्या है ... पीडब्लूएम का उपयोग करने की कोशिश एक दृश्यमान रैखिक तरीके से की जाती है, लेकिन मैं पूर्ण 256 चरण का संकल्प चाहता हूं। मैन्युअल रूप से एक वक्र बनाने के लिए 256 संख्याओं का अनुमान लगाने की कोशिश करना आसान काम नहीं है!

मैं एक विशेषज्ञ गणितज्ञ नहीं हूं, लेकिन मैं वास्तव में यह जानने के बिना कि कुछ कार्यों और सूत्रों को जोड़कर कुछ बुनियादी घटता उत्पन्न करने के लिए पर्याप्त जानता हूं। मुझे लगता है कि स्प्रेडशीट (मैंने एक्सेल का उपयोग किया है) का उपयोग करके आप 0 से 255 तक की संख्या के साथ खेल सकते हैं, अगले सेल में कुछ सूत्र डाल सकते हैं, और उन्हें ग्राफ कर सकते हैं।

मैं फ़ेडिंग करने के लिए पिक असेंबलर का उपयोग कर रहा हूँ, और इसलिए आप एक फॉर्मूला ( ="retlw 0x" & DEC2HEX(A2)) के साथ कोडांतरक कोड उत्पन्न करने के लिए स्प्रेडशीट भी प्राप्त कर सकते हैं । यह एक नए वक्र को आज़माने के लिए बहुत तेज़ और आसान बनाता है।

लॉग और एसआईएन फ़ंक्शंस, दोनों के औसत और कुछ अन्य चीजों के साथ खेलने के बाद, मैं वास्तव में सही वक्र प्राप्त नहीं कर सका। क्या हो रहा है कि फीका का मध्य भाग निचले और उच्च स्तर की तुलना में धीमा हो रहा था। इसके अलावा, अगर एक फीका-अप तुरंत एक फीका-डाउन होता है, तो तीव्रता में तेज ध्यान देने योग्य स्पाइक था। क्या जरूरत है (मेरी राय में) एक एस कर्व है।

विकिपीडिया पर एक त्वरित खोज एस वक्र के लिए आवश्यक सूत्र के साथ आई। मैंने इसे अपनी स्प्रैडशीट में प्लग किया, और इसे अपने मूल्यों की सीमा में गुणा करने के लिए कुछ समायोजन किए, और इसके साथ आया:

एस कर्व

मैंने इसे अपनी कठोरता पर परीक्षण किया, और इसने खूबसूरती से काम किया।

मेरे द्वारा उपयोग किया गया एक्सेल सूत्र यह था:

=1/(1+EXP(((A2/21)-6)*-1))*255

जहां A2, स्तंभ A में पहला मान है, जो प्रत्येक मान के लिए A3, A4, ..., A256 बढ़ाता है।

मुझे पता नहीं है कि यह गणितीय रूप से सही है या नहीं, लेकिन यह वांछित परिणाम पैदा करता है।

यहां 256 स्तरों का पूरा सेट दिया गया है जिनका मैंने उपयोग किया है:

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05,
0x05, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x09, 0x0A, 0x0A, 0x0B, 0x0B,
0x0C, 0x0C, 0x0D, 0x0D, 0x0E, 0x0F, 0x0F, 0x10, 0x11, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1F, 0x20, 0x21, 0x23, 0x24, 0x26, 0x27, 0x29, 0x2B, 0x2C,
0x2E, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3A, 0x3C, 0x3E, 0x40, 0x43, 0x45, 0x47, 0x4A, 0x4C, 0x4F,
0x51, 0x54, 0x57, 0x59, 0x5C, 0x5F, 0x62, 0x64, 0x67, 0x6A, 0x6D, 0x70, 0x73, 0x76, 0x79, 0x7C,
0x7F, 0x82, 0x85, 0x88, 0x8B, 0x8E, 0x91, 0x94, 0x97, 0x9A, 0x9C, 0x9F, 0xA2, 0xA5, 0xA7, 0xAA,
0xAD, 0xAF, 0xB2, 0xB4, 0xB7, 0xB9, 0xBB, 0xBE, 0xC0, 0xC2, 0xC4, 0xC6, 0xC8, 0xCA, 0xCC, 0xCE,
0xD0, 0xD2, 0xD3, 0xD5, 0xD7, 0xD8, 0xDA, 0xDB, 0xDD, 0xDE, 0xDF, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5,
0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xED, 0xEE, 0xEF, 0xEF, 0xF0, 0xF1, 0xF1, 0xF2,
0xF2, 0xF3, 0xF3, 0xF4, 0xF4, 0xF5, 0xF5, 0xF6, 0xF6, 0xF6, 0xF7, 0xF7, 0xF7, 0xF8, 0xF8, 0xF8,
0xF9, 0xF9, 0xF9, 0xF9, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFB, 0xFB, 0xFB, 0xFB, 0xFB, 0xFB, 0xFC,
0xFC, 0xFC, 0xFC, 0xFC, 0xFC, 0xFC, 0xFC, 0xFC, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD,
0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF

इस समीकरण ने मेरे लिए पूरी तरह से काम किया।
इग्नासियो वाज़क्वेज़-अब्राम्स


4

मैं अपने डेक को रोशन करने के लिए एक एटीटीनी का उपयोग कर रहा था। ADC पिन से जुड़े बर्तन का उपयोग करके चमक को नियंत्रित किया जाता है।

कोशिश की गई घातीय फ़ंक्शन और उस पर आधारित PWM आउटपुट कथित चमक में रैखिक वृद्धि दे रहा है।

मैं इस सूत्र का उपयोग कर रहा था:

out = pow(out_max, in/in_max)

उपरोक्त गणना करने के लिए Attiny85 @ 8MHz लगभग 210us ले रहा था। प्रदर्शन में सुधार करने के लिए, लुकअप टेबल बनाया। चूंकि इनपुट 10-बिट एडीसी से था और एटीटीनी मेमोरी सीमित है, इसलिए मैं एक छोटी तालिका भी बनाना चाहता था।

1024 प्रविष्टियों के साथ लुकअप टेबल बनाने के बजाय, प्रोग्राम मेमोरी (PGMEM) में 256 प्रविष्टियों (512 बाइट्स) के साथ एक रिवर्स लुकअप टेबल बनाया। उस टेबल पर बाइनरी सर्च करने के लिए एक फंक्शन लिखा गया था। प्रत्येक लुकअप के लिए यह विधि केवल 28uS लेती है। यदि मैं एक प्रत्यक्ष लुकअप तालिका का उपयोग करता हूं, तो इसे 2kb मेमोरी की आवश्यकता होगी, लेकिन लुकअप केवल 4uS या तो ले जाएगा।

लुकअप टेबल में परिकलित मान इनपुट रेंज 32-991 का ही उपयोग करता है, एडीसी की निचली / ऊपरी श्रेणी को छोड़ने के मामले में, सर्किट में समस्या है।

नीचे अब मेरे पास क्या है।

// anti_log परीक्षण कार्यक्रम

/ * PIN6 (PB1) से जुड़ा एलईडी * /
# डेफिन एलईडी 1 

// एंटी-लॉग (रिवर्स) लुकअप टेबल 
// y = 0-255 (pwm आउटपुट), y_range = 256
// x = 0-1023 (10-बिट एडीसी इनपुट); 
// एडीसी आउट मानों के निचले / उच्च अंत का उपयोग नहीं किया जा सकता है
// पहले 32 और अंतिम 32 मानों को त्यागना।
// min_x = 32, max_x = 1023-min_x, x_range = 1024-2 * min_x
// ANTI_LOG [y] = राउंड (x_range * लॉग (y, आधार = y_range) + min_x)
// x का मान दिया गया, नीचे तालिका पर एक बाइनरी लुकअप करें
// Attiny85 @ 8MHz घड़ी के लिए लगभग 28uS लेता है
PROGMEM prog_uint16_t ANTI_LOG [] = {
  0x0000, 0x0020, 0x0098, 0x00de, 0x0110, 0x0137, 0x0156, 0x0171, 0x0188, 0x019c, 0x01af, 0x01bf, 0x01ce, 0x01dc, 0x01e9, 0x01f5
  0x0200, 0x020a, 0x0214, 0x021e, 0x0227, 0x022f, 0x0237, 0x023f, 0x0246, 0x024d, 0x0254, 0x025b, 0x0261, 0x0261, 0x0267, 0x0267, 0x0267
  0x0278, 0x027d, 0x0282, 0x0288, 0x028c, 0x0291, 0x0296, 0x029a, 0x029f, 0x02a3, 0x02a7, 0x02ab, 0x02ab, 0x02af, 0x02af, 0x02af, 0x02af, 0x028af
  0x02be, 0x02c2, 0x02c5, 0x02c9, 0x02cc, 0x02cf, 0x02d3, 0x02d6, 0x02d9, 0x02d9, 0x02dc, 0x02d2, 0x02d2, 0x02c2, 0x02c2, 0x02c2, 0x02c2, 0x02c2, 0x02c2, 0x02c2, 0x02c2, 0x02c2, 0x02c2, 0x02c2, 0x02c2, 0x02c2
  0x02f0, 0x02f3, 0x02f5, 0x02f8, 0x02fa, 0x02fd, 0x0300, 0x0302, 0x0304, 0x0307, ​​0x0309, 0x030b, 0x030e, 0x030e, 0x0310
  0x0317, 0x0319, 0x031b, 0x031d, 0x031f, 0x0321, 0x0323, 0x0325, 0x0327, 0x0329, 0x032b, 0x032d, 0x032f, 0x033f, 0x0331, 0x0331, 0x0331
  0x0336, 0x0338, 0x033a, 0x033c, 0x033d, 0x033f, 0x0341, 0x0342, 0x0344, 0x0346, 0x0347, 0x0349, 0x034b, 0x034b, 0x034b, 0x034c, 0x034c
  0x0351, 0x0352, 0x0354, 0x0355, 0x0357, 0x0358, 0x035a, 0x035b, 0x035d, 0x035e, 0x0360, 0x0361, 0x0363, 0x0363, 0x0364, 0x0364, 0x0364
  0x0368, 0x0369, 0x036b, 0x036c, 0x036d, 0x036f, 0x0370, 0x0371, 0x0372, 0x0374, 0x0375, 0x0376, 0x0378, 0x0378, 0x0379, 0x0379।
  0x037c, 0x037e, 0x037f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0385, 0x0386, 0x0387, 0x0388, 0x0389, 0x038a, 0x038a, 0x038b, 0x038a।
  0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039b, 0x039b, 0x0390
  0x039f, 0x03a1, 0x03a2, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7, 0x03a8, 0x03a8, 0x03a9, 0x03a9, 0x03a9, 0x03a9, 0x03a9, 0x03a9, 0x03a9, 0x03a9, 0x03a9, 0x03a9, 0x03a9, 0x03a9, 0x03a9, 0x03a9, 0x03a2, 0x03a9
  0x03ae, 0x03b0, 0x03b1, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b4, 0x03b5, 0x03b6, 0x03b6, 0x03b7, 0x03b7, 0x03b7, 0x03b7, 0x03b7, 0x03b7, 0x03b7, 0x03b7, 0x03b7, 0x03b7, 0x03b7, 0x03b7, 0x03b7, 0x03b7
  0x03bc, 0x03bd, 0x03bf, 0x03bf, 0x03bf, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c3, 0x03c3, 0x03c4, 0x03c5, 0x03c5, 0x03c5, 0x03c5, 0x03c5, 0x03c5, 0x03c5, 0x03c5, 0x03c5, 0x03c5, 0x03c4, 0x03c5, 0x03c5, 0x03cf, 0x03cf, 0x03c5, 0x03c5, 0x03c5, 0x03c5, 0x03c5, 0x03c3, 0x03c3, 0x03c3, 0x03c3, 0x03c3, 0x03c3, 0x03c3, 0x03c3
  0x03c9, 0x03ca, 0x03cb, 0x03cb, 0x03cc, 0x03cd, 0x03cd, 0x03ce, 0x03cf, 0x03d0, 0x03d0, 0x03d1, 0x03d2, 0x03d2, 0x03d2, 0x03d2, 0x03d2, 0x03d2
  0x03d5, 0x03d6, 0x03d6, 0x03d7, 0x03d8, 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03db, 0x03dc, 0x03dd, 0x03dd, 0x03de, 0x03df, 0x03df
};

// बाइनरी लुकअप उपरोक्त तालिका का उपयोग करके।
बाइट एंटीलोग (इंट x)
{
  बाइट y = 0x80;
  int av;
  for (int i = 0x40; मैं> 0; मैं >> = 1)
  {
    av = pgm_read_word_near (ANTI_LOG + y);
    अगर (av> x)
    {
      y - = i;
    }
    और अगर (av <x) 
    {
      y | = i;
    }
    अन्य
    {
      वापसी y;
    }
  }
  अगर (pgm_read_word_near (ANTI_LOG + y)> x)
  {
    y - = 1;
  }
  वापसी y;
}


व्यर्थ व्यवस्था()
{
  पिनमोड (LED, OUTPUT);
  digitalWrite (LED, LOW);
}

#define MIN_X 0
# डेफिन MAX_X 1024

शून्य लूप ()
{
  int i;
  // antilog_drive
  (i = MIN_X; मैं <MAX_X; i ++) के लिए
  {
    एनालॉगवर्इट (एलईडी, एंटीलोग (आई));
    देरी (2);
  }
  (- I; i> = MIN_X; i--)
  {
    एनालॉगवर्इट (एलईडी, एंटीलोग (आई));
    देरी (2);
  }
  देरी (1000);
  // रैखिक ड्राइव
  (i = MIN_X; मैं <MAX_X; i ++) के लिए
  {
    एनालॉगवर्इट (एलईडी, i >> 2);
    देरी (2);
  }
  (- I; i> = MIN_X; i--)
  {
    एनालॉगवर्इट (एलईडी, i >> 2);
    देरी (2);
  }
  देरी (2000);
}

1

यह पीडीएफ आवश्यक वक्र की व्याख्या करता है, जाहिरा तौर पर एक लघुगणक। यदि आपके पास एक रैखिक डिमर (आपका पीडब्लूएम मूल्य) है, तो फ़ंक्शन लॉगरिदमिक होना चाहिए।

यहां आप 8 बिट पीडब्लूएम के लिए चमक के 32 चरणों के लिए एक लुकअप टेबल पा सकते हैं।

यहां 16 चरणों के लिए।


1

यहाँ है कि मैं क्या arduino मंच प्रतिक्रिया के आधार पर किया है । मैंने 0 से 255 तक मानों की गणना की है, इसलिए यह arduino पर pwm के साथ उपयोग करना आसान है

byte ledLookupTable[] = {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,7,7,7,8,8,8,9,9,9,10,10,11,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,19,19,20,20,21,21,22,23,23,24,24,25,26,26,27,28,28,29,30,30,31,32,32,33,34,35,35,36,37,38,38,39,40,41,42,42,43,44,45,46,47,47,48,49,50,51,52,53,54,55,56,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,73,74,75,76,77,78,79,80,81,82,84,85,86,87,88,89,91,92,93,94,95,97,98,99,100,102,103,104,105,107,108,109,111,112,113,115,116,117,119,120,121,123,124,126,127,128,130,131,133,134,136,137,139,140,142,143,145,146,148,149,151,152,154,155,157,158,160,162,163,165,166,168,170,171,173,175,176,178,180,181,183,185,186,188,190,192,193,195,197,199,200,202,204,206,207,209,211,213,215,217,218,220,222,224,226,228,230,232,233,235,237,239,241,243,245,247,249,251,253,255};

तो Arduino पर उपयोग करने के लिए बस ऐसा ही करें:

analogWrite(ledPin, ledLookupTable[brightness]); //with brighness between 0 and 255

आशा है कि यह कुछ लोगों के लिए उपयोगी है;)


1

मैं अब इसके साथ काम कर रहा हूं, और मैं थोड़ा अलग तरीका अपना रहा हूं। मुझे 256 स्तरों की चमक चाहिए, लेकिन एक रैखिक 0-255 रेंज को गैर-रैखिक 0-255 श्रेणी की हवाओं में मैप करना, जैसा कि आप कुछ अन्य उत्तरों में देख सकते हैं, बहुत सारी डुप्लिकेट प्रविष्टियों के साथ। (यानी, आपके कई इनपुट मूल्य समान चमक स्तर में परिणत होते हैं।)

मैंने एक 0-256 इनपुट रेंज को 0-1023 आउटपुट रेंज में मैप करने के लिए एल्गोरिदम को संशोधित करने की कोशिश की, लेकिन यहां तक ​​कि 0. मान के लिए कई मान भी थे। इसलिए मैं कुछ अलग करने की कोशिश कर रहा हूं - मैं 0-255 के स्तर का उपयोग कर रहा हूं 0-769 (1023 शून्य से 255) सीमा में गैर-रेखीय मान उत्पन्न करने के लिए sin() , फिर इनपुट लेवल को 0-1023 की सीमा में कोई डुप्लिकेट के साथ आउटपुट प्राप्त करने के लिए जोड़ें। मैं 1023 के काउंटर का उपयोग करने के लिए टाइमर को कॉन्फ़िगर करूंगा, और PWM आउटपुट के लिए कंप्रेशर को लुकअप टेबल से मानों के आधार पर सेट कर सकता हूं कि मुझे कौन सा प्रकाश स्तर चाहिए (0-255)।

यहाँ सी प्रोग्राम है जिसका उपयोग मैंने अपने लुकअप टेबल को उत्पन्न करने के लिए किया है:

#include <stdio.h>
#include <math.h>

int main() {
    int i;
    double j;
    int k;

    printf( "int brightness[] = {\n" );
    for( i=0; i<256; i++ ) {
        // 0 - 255 => 1.0 - 0.0, multiply by 90 degrees (in radians)
        j = (1 - (i / 255.0)) * M_PI / 2;
        j = sin( j );
        k = (1023-255) - j * (1023-255);
        printf( "%s%d%s%s",
                (((i % 8) == 0) ? "    " : " "), // leading space at start of line
                k+i,
                ((i < 255) ? "," : ""),          // comma after all but last value
                (((i % 8) == 7) ? "\n" : "")     // line break every 8 items
              );
    }
    printf( "  };\n" );
}

और यहाँ तालिका है:

int brightness[] = {
    0, 1, 2, 3, 4, 5, 6, 7,
    8, 10, 11, 12, 14, 15, 16, 18,
    19, 21, 22, 24, 25, 27, 29, 30,
    32, 34, 35, 37, 39, 41, 43, 44,
    46, 48, 50, 52, 54, 56, 58, 61,
    63, 65, 67, 69, 72, 74, 76, 78,
    81, 83, 86, 88, 91, 93, 96, 98,
    101, 103, 106, 109, 111, 114, 117, 120,
    122, 125, 128, 131, 134, 137, 140, 143,
    146, 149, 152, 155, 158, 161, 164, 168,
    171, 174, 177, 181, 184, 187, 191, 194,
    198, 201, 205, 208, 212, 215, 219, 222,
    226, 230, 233, 237, 241, 244, 248, 252,
    256, 260, 263, 267, 271, 275, 279, 283,
    287, 291, 295, 299, 303, 307, 312, 316,
    320, 324, 328, 333, 337, 341, 345, 350,
    354, 358, 363, 367, 372, 376, 381, 385,
    390, 394, 399, 403, 408, 412, 417, 422,
    426, 431, 436, 440, 445, 450, 455, 459,
    464, 469, 474, 479, 484, 489, 493, 498,
    503, 508, 513, 518, 523, 528, 533, 538,
    543, 548, 554, 559, 564, 569, 574, 579,
    584, 590, 595, 600, 605, 610, 616, 621,
    626, 632, 637, 642, 647, 653, 658, 664,
    669, 674, 680, 685, 690, 696, 701, 707,
    712, 718, 723, 729, 734, 740, 745, 751,
    756, 762, 767, 773, 778, 784, 790, 795,
    801, 806, 812, 818, 823, 829, 834, 840,
    846, 851, 857, 863, 868, 874, 880, 885,
    891, 897, 902, 908, 914, 920, 925, 931,
    937, 942, 948, 954, 960, 965, 971, 977,
    982, 988, 994, 1000, 1005, 1011, 1017, 1023
};

log()एक बार इसे उठाकर चलाने के बाद, मैं संभवतः अन्य कार्यों (जैसे ) की जांच करूँगा ।


हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.