PWM ব্যবহার করার সময় LEDগুলিতে অ-লিনিয়ার উজ্জ্বলতার জন্য সংশোধন করা হচ্ছে Cor

33

পিডব্লিউএম সহ কোনও এলইডি ড্রাইভিং করার সময়, উজ্জ্বলতা (যেমন আমি বুঝতে পারি) দায়িত্ব চক্রের সাথে রৈখিকভাবে স্কেল করে না। উজ্জ্বলতা র‌্যাম্প আপ করতে ধীর গতিতে, তারপরে কর্তব্য চক্রের সাথে তাত্পর্যপূর্ণভাবে বৃদ্ধি পায়।

কেউ কি সংশোধন ফ্যাক্টর, বা অন্য কাজের ভিত্তিতে থাম্ব নিয়মের পরামর্শ দিতে পারেন?

led  pwm 
— টবি জাফি
সূত্র
আমি যখন নাইট রাইডার কাফ লিঙ্কগুলির একটি জুটি তৈরি করেছি, তখন বিবর্ণটিকে সুন্দর দেখানোর জন্য আমাকে এক্স ^ 10 ব্যবহার করতে হয়েছিল!
— রকেটম্যাগনেট
3
আপনি কি নিশ্চিত যে এটি "প্রথমে উজ্জ্বলতা তাত্পর্যপূর্ণভাবে বৃদ্ধি পায়, এবং তারপরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে বেড়ে যায়"?
— দিমিত্রি গ্রিগরিয়েভ
1
আমি বিশ্বাস করি আমাদের চোখ উজ্জ্বলতার প্রতি লোগারিথমে প্রতিক্রিয়া জানায়।
— DKNguyen

উত্তর:

13

১ levels টি স্তরের জন্য "হাত দ্বারা" একটি সরল চেহারা আপ টেবিল করা সহজ এবং পিডব্লিউএম নিয়ামককে পাস করার জন্য একটি 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;
— Axeman
সূত্র
আমি আপনার সূত্রটি ঠিক কী তা জানার চেষ্টা করছি। এটি উল্লেখযোগ্যভাবে f (x) = x ^ 2 এর কাছাকাছি, তবে বাঁকটি যথেষ্ট গভীর নয়। f (x) = x ^ 3/13 আমাকে অনেক কাছে পেয়েছে।
— ajs410
এটি কোনও সূত্র (ইচ্ছাকৃতভাবে নয়) ... আমি লিনিয়ারাইজারের প্রাথমিক মানগুলি অনুমান করে দেখেছি :-)। এরপরে আমি অ্যারে চালিত করেছি, নেতৃত্বাধীন কলামগুলিকে উজ্জ্বলতার সাথে চালিত করেছি এবং একটি এমনকি র‌্যাম্প পেতে মানগুলি ট্যুইক করেছি। এটি কেবলমাত্র 16 টি স্তর সহ সত্যই সহজ।
— অ্যাক্সিমান
1
@ ajs410 - আরও মতো দেখাচ্ছে2n আমায়: প্রথম 1বিট বেশী বা কম বদল আনতে প্রতিটি পদক্ষেপ অবশিষ্ট 1 অবস্থান ত্যাগ করেন।
— স্টিভেন্ভ
17

তত্ত্বের ক্ষেত্রে এটি ক্ষতিকারক হওয়া উচিত, তবে আমি চতুর্ভুজ ফাংশনটি ব্যবহার করে ম্লান হওয়ার জন্য সেরা ফলাফল পেয়েছি।

আমিও মনে করি আপনি এটি পিছনের দিকে পেয়েছেন। কম শুল্ক চক্রে উজ্জ্বলতার অনুভূত বৃদ্ধি প্রায় সম্পূর্ণ ডিউটি ​​চক্রের তুলনায় অনেক বড়, যেখানে উজ্জ্বলতা বৃদ্ধি প্রায় অনিবার্য।

— starblue
সূত্র
আরও দেখুন গামা সংশোধন ।
— তারাব্লিউ
17

আমি গত কয়েকদিন ধরে এই বিষয়ে সন্ধান করছিলাম কারণ আমার একই সমস্যা রয়েছে ... দৃশ্যমান রৈখিক উপায়ে পিডাব্লুএম ব্যবহার করে এলইডিগুলিকে ম্লান করার চেষ্টা করছি, তবে আমি সম্পূর্ণ 256 ধাপের রেজোলিউশন চাই। ম্যানুয়ালি একটি বক্ররেখা তৈরি করতে 256 নম্বর অনুমান করার চেষ্টা করা সহজ কাজ নয়!

আমি একজন বিশেষজ্ঞ গণিতবিদ নই, তবে তারা কীভাবে কাজ করে তা না জেনে কয়েকটি ফাংশন এবং সূত্র একত্রিত করে কিছু প্রাথমিক বক্ররেখা উত্পন্ন করতে আমি যথেষ্ট জানি। আমি দেখতে পেলাম যে একটি স্প্রেডশিট (আমি এক্সেল ব্যবহার করেছি) ব্যবহার করে আপনি 0 থেকে 255 পর্যন্ত সংখ্যার সেট নিয়ে প্রায় খেলতে পারেন, পরবর্তী কক্ষে কয়েকটি সূত্র রেখে দিতে পারেন এবং সেগুলি আঁকুন।

আমি বিবর্ণ করতে পিক এসেম্ব্লার ব্যবহার করছি এবং তাই আপনি এমনকি কোনও সূত্র ( ="retlw 0x" & DEC2HEX(A2)) দিয়ে এসেম্বলারের কোডটি তৈরি করতে স্প্রেডশিটটি পেতে পারেন । এটি খুব দ্রুত এবং একটি নতুন বক্ররেখার চেষ্টা করা সহজ করে তোলে।

এলওজি এবং এসআইএন ফাংশন, দুটির গড় এবং আরও কয়েকটি জিনিস নিয়ে বেশ কিছুটা খেলার পরে আমি সত্যিই সঠিক বক্ররেখা পেতে পারি না। যা হচ্ছে তা হ'ল বিবর্ণের মাঝের অংশটি নিম্ন এবং উচ্চ স্তরের তুলনায় ধীরে ধীরে ঘটছিল। এছাড়াও, যদি বিবর্ণ অবিলম্বে ফেইড-ডাউন অনুসরণ করা হয় তবে তীব্রতার মধ্যে একটি তীব্র লক্ষণীয় স্পাইক ছিল। যা প্রয়োজন (আমার মতে) একটি এস বক্ররেখা।

উইকিপিডিয়ায় একটি দ্রুত অনুসন্ধান এস বক্রের জন্য প্রয়োজনীয় সূত্র নিয়ে আসে। আমি এটিকে আমার স্প্রেডশীটে প্লাগ ইন করে এটিকে আমার মানগুলির পরিসীমা জুড়ে বহুবার করার জন্য কয়েকটি সামঞ্জস্য করেছি এবং এটি নিয়ে এসেছি:

S curve

আমি এটি আমার রগতে পরীক্ষা করেছি এবং এটি সুন্দরভাবে কাজ করেছে।

আমি যে এক্সেল সূত্রটি ব্যবহার করেছি তা হ'ল:

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

যেখানে A2 হ'ল কলামের প্রথম মান, যা প্রতিটি মানের জন্য 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
— BG100
সূত্র
এই সমীকরণটি আমার পক্ষে পুরোপুরি কাজ করেছিল।
— Ignacio Vazquez-Abram
4

আমি আমার ডেক জ্বালানোর জন্য একটি অ্যাটিনি ব্যবহার করছিলাম। উজ্জ্বলতা ADC পিনের সাথে যুক্ত একটি পাত্র ব্যবহার করে নিয়ন্ত্রণ করা হয়।

চেষ্টা করা এক্সফোনেনশিয়াল ফাংশন এবং এর ভিত্তিতে পিডাব্লুএমএম আউটপুট অনুমিত উজ্জ্বলতায় রৈখিক বৃদ্ধি প্রদান করে বলে মনে হচ্ছে।

আমি এই সূত্রগুলি ব্যবহার করছিলাম:

out = pow(out_max, in/in_max)

Attiny85 @ 8MHz উপরের গণনাটি সম্পাদন করতে প্রায় 210us সময় নিচ্ছিল। কর্মক্ষমতা উন্নত করতে, একটি সারণী তৈরি করে। ইনপুট যেহেতু 10-বিট এডিসি থেকে ছিল এবং এটিটিনি মেমরিটি সীমাবদ্ধ তাই আমি আরও একটি ছোট টেবিল তৈরি করতে চেয়েছিলাম।

1024 টি এন্ট্রি সহ লুক টেবিল তৈরি করার পরিবর্তে প্রোগ্রামের মেমোরিতে (পিজিএমইএম) 256 এন্ট্রি (512 বাইট) সহ একটি বিপরীত লক টেবিল তৈরি করে। সেই টেবিলে বাইনারি অনুসন্ধান করতে একটি ফাংশন লেখা হয়েছিল written এই পদ্ধতিটি প্রতিটি দেখার জন্য কেবল 28uS নেয়। আমি যদি সরাসরি দেখার টেবিল ব্যবহার করি তবে এটির জন্য 2 কিলোবাইট মেমরির প্রয়োজন হবে, তবে অনুসন্ধানে কেবল 4uS বা তার বেশি লাগবে।

সন্ধানের সারণীতে গণনা করা মানগুলি ইনপুট পরিসরটি কেবলমাত্র 32-991 ব্যবহার করে, সার্কিটের ক্ষেত্রে যদি সমস্যা থাকে তবে এডিসির নিম্ন / উচ্চতর পরিসরটি ত্যাগ করে।

নীচে আমি এখন যা আছে।

// অ্যান্টি_লগ পরীক্ষা প্রোগ্রাম

/ * পিন 6 (পিবি 1) এর সাথে সংযুক্ত এলইডি * / /
# নির্ধারণ এলইডি 1 

// অ্যান্টি-লগ (বিপরীত) চেহারা সারণী 
// y = 0-255 (pwm আউটপুট), y_range = 256
// এক্স = 0-1023 (10-বিট এডিসি ইনপুট); 
// এডিসি আউট মানগুলির নিম্ন / উচ্চতর প্রান্তটি ধরে নেওয়া যায় না
// প্রথম 32 এবং শেষ 32 টি মান বাতিল হচ্ছে।
// মিনিট_এক্স = 32, সর্বোচ্চ_ x = 1023-মিনিট x, এক্স_রেঞ্জ = 1024-2 * মিনিট_এক্স
// এন্টি_লগ [y] = বৃত্তাকার (এক্স_আরঞ্জ * লগ (ওয়াই, বেস = y_আরজ) + মিনিট x)
// এর x এর মান দেওয়া হয়েছে, নীচের টেবিলটিতে একটি বাইনারি অনুসন্ধান করুন
// Attiny85 @ 8MHz ঘড়ির জন্য প্রায় 28uS লাগে
PROGMEM prog_uint16_t এন্টি_লগ [] = {
  0x0000, 0x0020, 0x0098, 0x00de, 0x0110, 0x0137, 0x0156, 0x0171, 0x0188, 0x019c, 0x01af, 0x01bf, 0x01ce, 0x01dc, 0x01e5, 0x01f5
  0x0200, 0x020a, 0x0214, 0x021e, 0x0227, 0x022f, 0x0237, 0x023f, 0x0246, 0x024d, 0x0254, 0x025b, 0x0261, 0x0267, 0x026d, 0x0273,
  0x0278, 0x027d, 0x0282, 0x0288, 0x028c, 0x0291, 0x0296, 0x029a, 0x029f, 0x02a3, 0x02a7, 0x02ab, 0x02b, 0x02b7, 0x02b7, 0x02b7
  0x02be, 0x02c2, 0x02c5, 0x02c9, 0x02cc, 0x02cf, 0x02d3, 0x02d6, 0x02d9, 0x02dc, 0x02d8, 0x02e8, 0x02e8
  0x02f0, 0x02f3, 0x02f5, 0x02f8, 0x02fa, 0x02fd, 0x0300, 0x0302, 0x0304, 0x0307, ​​0x0309, 0x030b, 0x030e, 0x0310, 0x0312, 0x0310
  0x0317, 0x0319, 0x031 বি, 0x031d, 0x031f, 0x0321, 0x0323, 0x0325, 0x0327, 0x0329, 0x032b, 0x032d, 0x032f, 0x0331, 0x0333, 0x0334,
  0x0336, 0x0338, 0x033a, 0x033c, 0x033d, 0x033f, 0x0341, 0x0342, 0x0344, 0x0346, 0x0347, 0x0349, 0x034b, 0x034c, 0x034f,
  0x0351, 0x0352, 0x0354, 0x0355, 0x0357, 0x0358, 0x035a, 0x035b, 0x035d, 0x035e, 0x0360, 0x0361, 0x0363, 0x0364, 0x0365, 0x0367,
  0x0368, 0x0369, 0x036b, 0x036c, 0x036d, 0x036f, 0x0370, 0x0371, 0x0372, 0x0374, 0x0375, 0x0376, 0x0378, 0x0379, 0x037a, 0x037b,
  0x037c, 0x037e, 0x037f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0385, 0x0386, 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038e, 0x038e,
  0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
  0x039f, 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7, 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ab, 0x03ab
  0x03ae, 0x03af, 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b4, 0x03b5, 0x03b6, 0x03b9, 0x03b, 0x03b9
  0x03bc, 0x03bd, 0x03be, 0x03bf, 0x03bf, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c3, 0x03c6, 0x03c7, 0x03c7
  0x03c9, 0x03ca, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03cd, 0x03ce, 0x03cf, 0x03d0, 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d3, 0x03d3, 0x03d3, 0x03d3, 0x03d3, 0x03d3
  0x03d5, 0x03d6, 0x03d6, 0x03d7, 0x03d8, 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03db, 0x03d, 0x03d, 0x03d, 0x03d,
};

// উপরের টেবিল ব্যবহার করে বাইনারি লুক।
বাইট অ্যান্টলগ (ইনট এক্স)
{
  বাইট y = 0x80;
  int av;
  (int i = 0x40; i> 0; i >> = 1) এর জন্য
  {
    av = pgm_read_word_near (এন্টি_এলজি + ই);
    যদি (অ্যাভ> এক্স)
    {
      y - = i;
    }
    অন্যথায় যদি (av <এক্স) 
    {
      y | = i;
    }
    আর
    {
      প্রত্যাবর্তন y;
    }
  }
  যদি (পিজিএম_ড্রেড_ওয়ার্ড_নেয়ার (এন্টি_লগ + ই)> এক্স)
  {
    y - = 1;
  }
  প্রত্যাবর্তন y;
}


অকার্যকর সেটআপ()
{
  পিনমোড (এলইডি, আউটপুট);
  ডিজিটাল রাইট (এলইডি, কম);
}

# নির্ধারণ MIN_X 0 X
# নির্ধারণ MAX_X 1024

অকার্যকর লুপ ()
{
  int i;
  // antilog_drive
  (i = MIN_X; i <MAX_X; i ++) এর জন্য
  {
    অ্যানালগ রাইট (এলইডি, অ্যান্টলগ (i))
    বিলম্ব (2);
  }
  (--i; i> = MIN_X; i--) এর জন্য
  {
    অ্যানালগ রাইট (এলইডি, অ্যান্টলগ (i))
    বিলম্ব (2);
  }
  বিলম্ব (1000);
  // লিনিয়ার ড্রাইভ
  (i = MIN_X; i <MAX_X; i ++) এর জন্য
  {
    অ্যানালগ রাইট (এলইডি, আই >> 2);
    বিলম্ব (2);
  }
  (--i; i> = MIN_X; i--) এর জন্য
  {
    অ্যানালগ রাইট (এলইডি, আই >> 2);
    বিলম্ব (2);
  }
  বিলম্ব (2000);
}
— tash
সূত্র
1

This PDF explains the curve needed, apparently a logarithmic one. If you have a linear dimmer (your PWM value) then the function should be logarithmic.

Here you can find a lookup table for 32 steps of brightness for 8 bit PWM.

Here for 16 steps.

— FarO
সূত্র
1

Here is what I have done based on that arduino forum response. I have computed the values from 0 to 255 so it's easy to use with pwm on arduino

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};

Then to use on Arduino just do like that : 

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

Hope it is helpfull for some people ;)

— Jacob Yiendedoi
সূত্র
1

I'm dealing with this now, and I'm taking a slightly different approach. I want 256 levels of brightness, but mapping a linear 0-255 range to a non-linear 0-255 range winds up, as you can see in some of the other answers, with a lot of duplicate entries. (I.e., several of your input values result in the same brightness level.)

I tried modifying the algorithm to map a 0-256 input range to a 0-1023 output range, but even that had several values mapping to 0. So I'm trying something a bit different - I'm using the 0-255 level to generate non-linear values in the range 0-769 (that's 1023 minus 255) using sin(), then add that to the input level to get an output in the range 0-1023 with no duplicates. I'll configure a timer to use a counter of 1023, and set the comparator for the PWM output to values from the lookup table based on what lighting level I want (0-255).

Here's the C program I used to generate my lookup table:

#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" );
}

And here's the table:

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
};

I'll probably investigate other functions (like log()) once I've got this up and running.

— user112358
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.