Dimmable LED გამოყენებით Basys 3 დაფა: 5 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:17

ამ სახელმძღვანელოში ჩვენ ვაპირებთ ავაშენოთ და გავაკონტროლოთ გარე LED განათების სისტემა. არსებული ღილაკებით, მომხმარებელს შეუძლია შეამციროს LED ნათურა ნებისმიერ სასურველ სიკაშკაშეზე. სისტემა იყენებს Basys 3 დაფას და ის დაკავშირებულია პურის დაფასთან, რომელიც შეიცავს რეზისტორს და LED ნათურას. დაჭერილი "up" ღილაკის დაჭერა გაზრდის სიკაშკაშეს, ხოლო "ქვემოთ" ღილაკზე დაჭერით სიკაშკაშე ნულამდე. ეს არა მხოლოდ ხელს უშლის მომხმარებელს დააბრმავოს მზის სინათლის ნათურებით, არამედ ენერგიაც დაზოგავს!

ნაბიჯი 1: შექმენით შეყვანის მრიცხველი

ამ ნაბიჯისათვის ჩვენ ვქმნით კომპონენტს, რომელიც განსაზღვრავს სიკაშკაშის დონეს (საათის საშუალებით) ორი კონცენტრატორის გამოყენებით: ერთი იზრდება და ერთი მცირდება. VHDL- ის გამოყენებით, ჩვენ შევქმენით მრიცხველი D ფლიპ-ფლოპების გამოყენებით. "ზემოთ" ღილაკის დაჭერით უბიძგებს მომდევნო მდგომარეობას დღევანდელ მდგომარეობამდე, გამოდის შვიდი სეგმენტის ეკრანზე და LED ნათურაზე.

ერთეული updown_counter არის

პორტი (დღევანდელი_სახელი: გარეთ STD_LOGIC_VECTOR (3 ქვემოთ 0 -ზე); წინა_სამსახური: STD_LOGIC_VECTOR- ში (3 ქვემოდან 0 -მდე); შემდეგი_სახელი: STD_LOGIC_VECTOR (3 ქვემოთ 0 -მდე); clk: in STD_LOGGIC; ქვემოთ; განახლების დასრულება არქიტექტურა Updown_counter– ის ქცევა იწყება ფლოპი: პროცესი (შემდეგი_სახელმწიფო, clk, up_enable, down_enable, previous_state) დაიწყება თუ (იზრდება შემდეგი_სახელმწიფო; elsif (down_enable = '1' და არა (previous_state = "1111")) შემდეგ present_state <= წინა_ სახელმწიფო; დაასრულე თუ; დაასრულე თუ; პროცესის დასრულება ფლოპი; დასრულება ქცევითი;

ჩვენ ასევე გვჭირდება საათი თითოეული შეყვანისთვის (როდესაც ის იზრდება), ამიტომ ჩვენ ასევე შევქმენით საათის გამყოფი, რომელიც განსაზღვრავს რამდენად სწრაფად შეიძლება დააჭიროთ ღილაკებს სიკაშკაშის თითოეულ დონეს შორის. საათის გამყოფი საშუალებას გვაძლევს სწორად გამოვავლინოთ სწორი დონე შვიდი სეგმენტის ეკრანზე და გამოვავლინოთ თითოეული დონის ინტენსივობის შესაბამისი დონე.

პირი counter_clkDiv არის

პორტი (clk: std_logic; sclk: out std_logic); ბოლოს counter_clkDiv; არქიტექტურა my_clk_div of counter_clkDiv არის მუდმივი max_count: მთელი რიცხვი: = (10000000); სიგნალი tmp_clk: std_logic: = '0'; დაწყება my_div: პროცესი (clk, tmp_clk) ცვლადი div_cnt: მთელი რიცხვი: = 0; დავიწყოთ თუ (აღმავალი_ ზღვარი (clk)) შემდეგ თუ (div_cnt> = MAX_COUNT) შემდეგ tmp_clk <= არა tmp_clk; div_cnt: = 0; სხვა div_cnt: = div_cnt + 1; დაასრულე თუ; დაასრულე თუ; sclk <= tmp_clk; პროცესის დასრულება my_div; დასრულება my_clk_div;

ნაბიჯი 2: შექმენით LED საათის გამყოფი

ამ ნაბიჯისათვის ჩვენ ვქმნით საათის გამყოფს LED ნათურისთვის ინტენსივობის 16 სხვადასხვა დონის დასადგენად. როდესაც 0 არის გამორთული 15 – მდე, რომელიც აჩვენებს მაქსიმალურ სიკაშკაშეს, საათის გამყოფი ზრდის ყოველ ღილაკზე დაჭერას იმის მიხედვით, რაც ჩვენ სიკაშკაშის დონეს ვადგენთ. თითოეული დონის გაზრდა ნიშნავდა საათის გაზრდას LED ნათურისთვის. გვახსოვდეს, რომ სიკაშკაშე არ იზრდება ხაზობრივად, ჩვენ საათს მივაღწიეთ ყველაზე მაღლა და შეეძლო საათების შემცირება.

შენიშვნა: ჩვენ ვიყენებთ ლურჯ LED- ს. განსხვავებული ფერის გამოყენება (წითელი ფერის მსგავსად) სულ ოდნავ განსხვავებულ საათებს მოითხოვს; საშუალო სიკაშკაშის ცისფერი უკვე შეიძლება იყოს მაქსიმალური სიკაშკაშე წითელზე. ეს ხდება იმის გამო, რომ სინათლის სხვადასხვა ტალღის სიგრძე მოითხოვს სხვადასხვა რაოდენობის ენერგიას, უფრო მაგარი ფერები, როგორიცაა მეწამული და ლურჯი, მეტ ენერგიას მოითხოვს, ხოლო თბილი ფერები, როგორიცაა წითელი და ნარინჯისფერი, ნაკლებ ენერგიას.

ერთეული led_clkDiv არის პორტი (ამჟამინდელი მდგომარეობა: STD_LOGIC_VECTOR– ში (3 ქვემოთ 0 – ზე); clk: STD_LOGIC– ში; led_clk: გარეთ STD_LOGIC); ბოლოს led_clkDiv; არქიტექტურა led_clkDiv არის სიგნალი tmp_clk: std_logic: = '0'; გაზიარებული ცვლადი max_count: integer; დაიწყოს count_stuff: პროცესი (present_state) დასაწყისი case present_state არის როდესაც "0000" => max_count: = 0; როდესაც "0001" => max_count: = 2; როდესაც "0010" => max_count: = 4; როდესაც "0011" => max_count: = 6; როდესაც "0100" => max_count: = 8; როდესაც "0101" => max_count: = 10; როდესაც "0110" => max_count: = 12; როდესაც "0111" => max_count: = 14; როდესაც "1000" => max_count: = 16; როდესაც "1001" => max_count: = 25; როდესაც "1010" => max_count: = 50; როდესაც "1011" => max_count: = 100; როდესაც "1100" => max_count: = 150; როდესაც "1101" => max_count: = 200; როდესაც "1110" => max_count: = 250; როდესაც "1111" => max_count: = 300; დასასრული საქმე; პროცესის დასრულება count_stuff; my_div: პროცესი (clk, tmp_clk, present_state) ცვლადი div_cnt: მთელი რიცხვი: = 0; დაიწყება თუ (მზარდი_ ზღვარი (clk)) შემდეგ თუ (div_cnt> = max_count) მაშინ tmp_clk <= არა tmp_clk; div_cnt: = 0; სხვა div_cnt: = div_cnt + 1; დაასრულე თუ; დაასრულე თუ; led_clk <= tmp_clk; პროცესის დასრულება my_div; დასრულება ქცევითი;

ნაბიჯი 3: LED კონტროლერის შექმნა

ახლა, როდესაც ჩვენ მივაღწიეთ აქამდე, დროა საბოლოოდ გავაერთიანოთ ყველა ის კომპონენტი, რაც ჩვენ აქამდე შევქმენით LED კონტროლერის ფაილში.

მოკლედ რომ ვთქვათ, გამოყენებული კომპონენტებია შემდეგი:

• შეყვანის მრიცხველი (updown_counter)
• საათის გამყოფი (counter_clkDiv)
• LED საათის გამყოფი (led_clkDiv)
• შვიდი სეგმენტის ჩვენების დრაივერი (sseg_dec) (თანდართული ფაილი)

შვიდი სეგმენტის ჩვენების დრაივერი ფაქტობრივად ადრე არ განხილულა, რადგან ჩვენ რეალურად ვისესხეთ VHDL ფაილი დოქტორ ბრაიან მილისგან მისი გრძელი და რთული კოდის გამო. ის, რასაც არსებითად აკეთებს, არის ჩვენი ღილაკების შეყვანა ბასის 3 დაფაზე შვიდ სეგმენტიან ეკრანზე ისე, რომ ჩვენ ვიცოდეთ რა დონის სიკაშკაშეა.

წინსვლისას, LED კონტროლერი იყენებს ფლიპ ფლოპს რაოდენობის გაზრდის ან შემცირების მიზნით, რომელიც ერთდროულად აკონტროლებს როგორც შვიდი სეგმენტის ჩვენებას, ასევე LED ნათურის სიკაშკაშის დონეს.

ერთეულის მრიცხველი არის პორტი (clk: in STD_LOGIC; up_enable: in STD_LOGIC; down_enable: in STD_LOGIC; SEGMENTS: out STD_LOGIC_VECTOR (7 ქვემოთ 0); DISP_EN: out STD_LOGIC_VECTOR: 3 downtD) დასასრულის მრიცხველი; არქიტექტურის ქცევითი მრიცხველის კომპონენტია განახლება_შერიცხვი არის პორტი (დღევანდელი_სახელი: გარეთ STD_LOGIC_VECTOR (3 ქვემოთ 0 -მდე); წინა_სახელმწიფო: STD_LOGIC_VECTOR- ში (3 ქვევით 0 -მდე); შემდეგი_სახელმწიფო: STD_LOGIC_VECTOR- ში; 3 დაბლა; up_enable: STD_LOGIC); დასრულების კომპონენტი განახლებადი_კონტერი; კომპონენტი counter_clkDiv არის პორტი (clk: in std_logic; sclk: out std_logic); ბოლო კომპონენტი counter_clkDiv; კომპონენტი sseg_dec არის პორტი (ALU_VAL: std_logic_vector (7 ქვემოთ 0); SIGN: in std_logic; VALID: in std_logic; CLK: in std_logic; DISP_EN: out std_logic_vector (3 ქვემოთ 0); SEGMENTS: 7; დასასრული კომპონენტი sseg_dec; კომპონენტი led_clkDiv არის პორტი (ამჟამინდელი მდგომარეობა: STD_LOGIC_VECTOR– ში (3 ქვემოთ 0 – ზე); clk: STD_LOGIC– ში; led_clk: გარეთ STD_LOGIC); ბოლო კომპონენტი led_clkDiv; სიგნალი present_state: STD_LOGIC_VECTOR (3 ქვემოთ 0 -ზე): = "0000"; სიგნალი next_state: STD_LOGIC_VECTOR (3 ქვემოთ 0 -ზე): = "0000"; სიგნალი previous_state: STD_LOGIC_VECTOR (3 ქვემოთ 0 -ზე): = "0000"; სიგნალი Alu_Val: STD_LOGIC_VECTOR (7 ქვემოთ 0 -ზე); სიგნალის sclk: STD_LOGIC; დაიწყოს Alu_Val (7 ქვემოთ 4) <= "0000"; ალუ_ვალი (3 ქვემოთ 0 -ზე) <= დღევანდელი სახელმწიფო; შემდეგი_სახელმწიფო (0) <= არა (ახლანდელი_სახელი (0)); შემდეგი_სახელმწიფო (1) <= ამჟამინდელი_სახელი (0) ან დღევანდელი_სახელა (1); შემდეგი_სახელმწიფო (2) <= (დღევანდელი_სახელა (0) და აწმყო_სახელი (1)) ან დღევანდელი_სახელა (2); შემდეგი_სახელმწიფო (3) <= (დღევანდელი_სახელა (0) და აწმყო_სახელა (1) და აწმყო_სახელი (2)) ან დღევანდელი_სახელა (3); წინა_სახელმწიფო (0) <= არა (ახლანდელი_სახელი (0)); წინა_სახელმწიფო (1) <= ამჟამინდელი_სახელი (0) xn ან ახლანდელი_სახელი (1); წინა_სახელმწიფო (2) <= (დღევანდელი_სახელა (0) და არც ახლანდელი_სახელი (1)) ან დღევანდელი_სახელა (2); previous_state (3) sclk, next_state => next_state, previous_state => previous_state, up_enable => up_enable, down_enable => down_enable, present_state => present_state); ჩვენება: sseg_dec პორტის რუკა (ALU_VAL => Alu_Val, SIGN => '0', VALID => '1', CLK => clk, DISP_EN => DISP_EN, SEGMENTS => SEGMENTS); led_cliv: led_clkDiv პორტის რუკა (clk => clk, present_state => present_state, led_clk => led_clk); clk_div: counter_clkDiv პორტის რუკა (clk => clk, sclk => sclk); დასრულება ქცევითი;

ნაბიჯი 4: შეზღუდვებისა და შეკრების დადგენა

შეზღუდვები

Basys 3 დაფის სწორად დაყენებისა და პროგრამირების მიზნით, ჩვენ ჯერ უნდა დავაყენოთ ჩვენი შეზღუდვების ფაილი, რომელიც თან ერთვის ამ ნაბიჯს. შემდეგი პარამეტრები შესწორებულია:

ღილაკები

• T18 შეიცვალა "up_enable" (გაზრდის სიკაშკაშეს)
• U17 შეიცვალა "down_enable" (შემცირება სიკაშკაშე)

7 სეგმენტის ჩვენება

• W7, W6, U8, V8, U5, V5, U7, V7 წარმოადგენს ერთი ეკრანის თითოეულ სეგმენტს
• U2, U4, V4, W4 წარმოადგენს ჩვენებულ თითოეულ ანოდს (მხოლოდ 2 აქტიურია, რადგან ჩვენი ყველაზე მაღალი რიცხვი არის 15)

PMOD სათაური JC

JC7 არის ადგილი, სადაც ჩვენ ვუკავშირდებით LED ნათურის ერთ მავთულს, ხოლო მეორე მავთულს მივყავართ GROUND

ამ ყველაფრის დაყენების შემდეგ, თქვენ მხოლოდ უნდა შექმნათ თქვენი ბიტ -სტრიმი (რა პროგრამული უზრუნველყოფითაც იყენებთ, ანუ Vivado), დაპროგრამეთ თქვენი დაფა და ბუმი! თქვენ თვითონ მიიღეთ სამუშაო დაფა.

შენიშვნა: პინის რუქა შეგიძლიათ იხილოთ აქ Basys 3 მონაცემთა ცხრილში.

შეკრება

ნაბიჯი 5: თქვენი მბზინავი გადამრთველის გამოყენება

თუ ყველაფერი კარგად მიდის, თქვენ უნდა გქონდეთ სრულად ფუნქციონირების მბზინავი სისტემა. მოკლედ რომ ვთქვათ, ზედა ღილაკზე დაჭერით თქვენი სიკაშკაშე გაიზრდება (15 – მდე), ხოლო ქვემოთ ღილაკზე დაჭერით თქვენი სიკაშკაშე (ყველა 0 – მდე). ვიმედოვნებთ, რომ ყველაფერი კარგად იქნება თქვენი ახლა დასვენებული მხედველობისთვის!