В პირველი ნაწილი მე ვცდილობდი ვუთხრა ელექტრონიკის ინჟინრებს, რომლებიც გაიზარდა Arduino-ს შარვლებიდან, როგორ და რატომ უნდა წაიკითხონ მონაცემთა ცხრილები და სხვა დოკუმენტაცია მიკროკონტროლერებისთვის. ტექსტი დიდი აღმოჩნდა, ამიტომ დავპირდი, რომ ცალკე სტატიაში პრაქტიკულ მაგალითებს ვაჩვენებდი. ისე, მან თავის თავს რძის სოკო უწოდა...

დღეს მე გაჩვენებთ, თუ როგორ გამოიყენოთ მონაცემთა ცხრილები საკმაოდ მარტივი, მაგრამ აუცილებელი მრავალი პროექტისთვის, ამოცანების გადასაჭრელად STM32 (Blue Pill) და STM8 კონტროლერებზე. ყველა დემო პროექტი ეძღვნება ჩემს საყვარელ LED-ებს, ჩვენ მათ დიდი რაოდენობით გავანათებთ, რისთვისაც მოგვიწევს ყველანაირი საინტერესო პერიფერიული მოწყობილობის გამოყენება.

ტექსტი კვლავ უზარმაზარი აღმოჩნდა, ამიტომ მოხერხებულობისთვის ვაკეთებ შინაარსს:

STM32 Blue Pill: 16 LED DM634 დრაივერით
STM8: ექვსი PWM პინის დაყენება
STM8: 8 RGB LED სამ პინზე, წყვეტს

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

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

იმედი მაქვს, რომ ჩემი სტატია დაეხმარება ვინმეს ჰობიში ჩაძირვის მსგავს ეტაპზე.

STM32

16 LED DM634 და SPI

პატარა პროექტი Blue Pill-ის (STM32F103C8T6) და DM634 LED დრაივერის გამოყენებით. მონაცემთა ცხრილების გამოყენებით, ჩვენ გავარკვევთ დრაივერს, STM IO პორტებს და SPI-ს კონფიგურაციას.

DM634

ტაივანის ჩიპი 16 16-ბიტიანი PWM გამოსასვლელით, შეიძლება დაკავშირებული იყოს ჯაჭვებში. დაბალი დონის 12-ბიტიანი მოდელი ცნობილია შიდა პროექტიდან ლაითპაკეტი. ერთ დროს, DM63x-სა და კარგად ცნობილ TLC5940-ს შორის არჩევის დროს, DM ავირჩიე რამდენიმე მიზეზის გამო: 1) TLC ალიექსპრესზე ნამდვილად ყალბია, მაგრამ ეს არ არის; 2) DM აქვს ავტონომიური PWM საკუთარი სიხშირის გენერატორით; 3) მისი ყიდვა შეიძლებოდა იაფად მოსკოვში, ვიდრე ალისაგან ამანათის მოლოდინში. და, რა თქმა უნდა, საინტერესო იყო იმის სწავლა, თუ როგორ უნდა აკონტროლოთ ჩიპი თავად, ვიდრე მზა ბიბლიოთეკის გამოყენება. ჩიპები ახლა ძირითადად წარმოდგენილია SSOP24 შეფუთვაში; მათი შედუღება მარტივია ადაპტერზე.

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

DC ჩაძირვის წყაროები (ღია კანალიზაცია)

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

გარე რეზისტორები REXT-სა და GND-ს შორის გამომავალი დენის მნიშვნელობის დასაყენებლად

REXT პინსა და მიწას შორის დამონტაჟებულია საცნობარო რეზისტორი, რომელიც აკონტროლებს გამოსავლების შიდა წინააღმდეგობას, იხილეთ დიაგრამა მონაცემთა ცხრილის მე-9 გვერდზე. DM634-ში, ეს წინააღმდეგობა ასევე შეიძლება კონტროლდებოდეს პროგრამული უზრუნველყოფის საშუალებით, მთლიანი სიკაშკაშის დაყენებით (გლობალური სიკაშკაშე); ამ სტატიაში დეტალებში არ შევალ, უბრალოდ აქ დავდებ 2.2 - 3 kOhm რეზისტორს.

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

ჰო, აი, ჩინური ინგლისური მთელი თავისი დიდებით. ამის თარგმნა პრობლემურია, სურვილის შემთხვევაში შეგიძლიათ გაიგოთ, მაგრამ არსებობს სხვა გზა - ნახეთ, როგორ არის აღწერილი ფუნქციურად მსგავს TLC5940-თან კავშირი მონაცემთა ფურცელში:

... მოწყობილობაში მონაცემების შესატანად საჭიროა მხოლოდ სამი პინი. SCLK სიგნალის ამომავალი კიდე გადააქვს მონაცემებს SIN პინიდან შიდა რეესტრში. ყველა მონაცემის ჩატვირთვის შემდეგ, მოკლე მაღალი XLAT სიგნალი აკავებს თანმიმდევრულად გადაცემულ მონაცემებს შიდა რეესტრებში. შიდა რეგისტრები არის კარიბჭეები, რომლებიც ამოღებულია XLAT სიგნალის დონით. ყველა მონაცემი პირველ რიგში გადაეცემა ყველაზე მნიშვნელოვან ბიტს.

ლუქი – ჩამკეტი/ჩამკეტი/საკეტი.
ამომავალი ზღვარი - პულსის წინა კიდე
MSB ჯერ – ყველაზე მნიშვნელოვანი (მარცხნივ) ბიტი წინ.
საათის მონაცემებისთვის - მონაცემების თანმიმდევრულად გადაცემა (ბიტი-ბიტი).

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

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

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

ლურჯი აბი STM32F103

შესავალი: STM32 კონტროლერები ბევრად უფრო რთულია, ვიდრე Atmega328, ვიდრე შეიძლება საშინლად გამოიყურებოდეს. უფრო მეტიც, ენერგიის დაზოგვის მიზნით, თითქმის ყველა პერიფერიული მოწყობილობა გამორთულია დაწყებისას, ხოლო საათის სიხშირე არის 8 MHz შიდა წყაროდან. საბედნიეროდ, STM პროგრამისტებმა დაწერეს კოდი, რომელიც აწვდის ჩიპს "გამოთვლილ" 72 MHz-მდე და ყველა IDE-ის ავტორებმა, რომლებიც მე ვიცი, შეიტანეს ის ინიციალიზაციის პროცედურაში, ასე რომ, ჩვენ არ გვჭირდება დაკვრა (მაგრამ შეგიძლია თუ მართლა გინდა). მაგრამ მოგიწევთ პერიფერიული მოწყობილობების ჩართვა.

დოკუმენტაცია: Blue Pill აღჭურვილია პოპულარული STM32F103C8T6 ჩიპით, ამისთვის ორი სასარგებლო დოკუმენტია:

მონაცემთა ფურცელი მიკროკონტროლერებისთვის STM32F103x8 და STM32F103xB;
ცნობარი სახელმძღვანელო მთელი STM32F103 ხაზისთვის და სხვა.

მონაცემთა ცხრილში ჩვენ შეიძლება დავინტერესდეთ:

პინაუტები – ჩიპური პინოტები – იმ შემთხვევაში, თუ გადავწყვეტთ დაფების დამზადებას თავად;
მეხსიერების რუკა - მეხსიერების რუკა კონკრეტული ჩიპისთვის. საცნობარო სახელმძღვანელოს აქვს მთელი ხაზის რუკა და მასში მითითებულია რეგისტრები, რომლებიც ჩვენს არ გააჩნია.
Pin Definitions ცხრილი – ქინძისთავების ძირითადი და ალტერნატიული ფუნქციების ჩამონათვალი; "ლურჯი აბისთვის" შეგიძლიათ იპოვოთ უფრო მოსახერხებელი სურათები ინტერნეტში, ქინძისთავების ჩამონათვალით და მათი ფუნქციებით. ამიტომ, ჩვენ დაუყოვნებლივ ვეძებთ გუგლში Blue Pill pinout-ს და ხელთ გვაქვს ეს სურათი:

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

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

შეყვანის გამომავალი

Atmega328-ზე I/O ხორციელდება ძალიან მარტივად, რის გამოც STM32 ვარიანტების სიმრავლე შეიძლება დამაბნეველი იყოს. ახლა მხოლოდ დასკვნები გვჭირდება, მაგრამ მათაც კი აქვთ ოთხი ვარიანტი:

ღია დრენაჟი, ბიძგი-გაყვანილობა, ალტერნატიული ბიძგი-გაწევა, ალტერნატიული ღია გადინება

"Მოქაჩვა მიწოლა" (ბიძგი) არის ჩვეულებრივი გამომავალი Arduino-დან, პინს შეუძლია მიიღოს მნიშვნელობა HIGH ან LOW. მაგრამ "ღია გადინებით" არის სირთულეები, თუმცა სინამდვილეში აქ ყველაფერი მარტივია:

გამომავალი კონფიგურაცია / როდესაც პორტი მინიჭებულია გამომავალზე: / გამომავალი ბუფერი ჩართულია: / – გადინების რეჟიმის გახსნა: გამომავალი რეესტრში „0“ ჩართავს N-MOS-ს, გამომავალი რეესტრში „1“ ტოვებს პორტს Hi-Z რეჟიმში ( P-MOS არ არის გააქტიურებული ) / – Push-pull რეჟიმი: გამომავალ რეესტრში „0“ ააქტიურებს N-MOS-ს, „1“ გამომავალ რეესტრში ააქტიურებს P-MOS-ს.

ყველა განსხვავება ღია კანალიზაციას შორის (ღია სანიაღვრე) „დაძვრა-გაყვანიდან“ (ბიძგი) არის ის, რომ პირველ პინში არ შეუძლია მიიღოს HIGH მდგომარეობა: გამომავალ რეესტრში ერთის ჩაწერისას ის გადადის მაღალი წინააღმდეგობის რეჟიმში (მაღალი წინაღობა, Hi-Z). ნულის დაწერისას პინი ერთნაირად იქცევა ორივე რეჟიმში, როგორც ლოგიკურად, ასევე ელექტრონულად.

ნორმალურ გამომავალ რეჟიმში, პინი უბრალოდ ავრცელებს გამომავალი რეგისტრის შინაარსს. "ალტერნატივაში" ის კონტროლდება შესაბამისი პერიფერიული მოწყობილობებით (იხ. 9.1.4):

თუ პორტის ბიტი არის კონფიგურირებული, როგორც ალტერნატიული ფუნქციის პინი, პინის რეგისტრი გამორთულია და პინი დაკავშირებულია პერიფერიულ პინთან.

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

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

დაბოლოს, გამომავალი რეჟიმში ქინძისთავებს ასევე აქვთ საათის სიჩქარე. ეს არის ენერგიის დაზოგვის კიდევ ერთი ფუნქცია; ჩვენს შემთხვევაში, ჩვენ მას მაქსიმუმზე ვაყენებთ და ვივიწყებთ.

ასე რომ: ჩვენ ვიყენებთ SPI-ს, რაც ნიშნავს, რომ ორი პინი (მონაცემებით და საათის სიგნალით) უნდა იყოს „ალტერნატიული push-pull ფუნქცია“, ხოლო მეორე (LAT) უნდა იყოს „რეგულარული push-pull“. მაგრამ მათ მინიჭებამდე, მოდით გაუმკლავდეთ SPI-ს.

SPI

კიდევ ერთი პატარა საგანმანათლებლო პროგრამა

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

MOSI, ძირითადი გამომავალი / Slave შეყვანა: ეს პინი გადასცემს მონაცემებს მთავარ რეჟიმში და იღებს მონაცემებს slave რეჟიმში;
MISO, Master Input / Slave Output: პირიქით, იღებს მასტერში და გადასცემს სლავში;
SCK, სერიული საათი: ადგენს მონაცემთა გადაცემის სიხშირეს მთავარში ან იღებს საათის სიგნალს სლავში. არსებითად ურტყამს;
SS, Slave Select: ამ არხის დახმარებით მონამ იცის, რომ მისგან რაღაც ითხოვება. STM32-ზე მას უწოდებენ NSS, სადაც N = უარყოფითი, ე.ი. კონტროლერი ხდება მონა, თუ ამ არხში არის საფუძველი. ის კარგად ერწყმის Open Drain Output რეჟიმს, მაგრამ ეს სხვა ამბავია.

ისევე როგორც ყველაფერი, STM32-ზე SPI მდიდარია ფუნქციონირებით, რაც გარკვეულწილად ართულებს მის გაგებას. მაგალითად, მას შეუძლია იმუშაოს არა მხოლოდ SPI-ით, არამედ I2S ინტერფეისითაც და დოკუმენტაციაში მათი აღწერილობები შერეულია, აუცილებელია ზედმეტის დროულად მოჭრა. ჩვენი ამოცანა ძალიან მარტივია: ჩვენ მხოლოდ მონაცემების გაგზავნა გვჭირდება მხოლოდ MOSI და SCK გამოყენებით. ჩვენ გადავდივართ განყოფილებაში 25.3.4 (ნახევრად დუპლექსური კომუნიკაცია, ნახევრად დუპლექსური კომუნიკაცია), სადაც ვპოულობთ 1 საათი და 1 ცალმხრივი მონაცემთა მავთული (1 საათის სიგნალი და 1 ცალმხრივი მონაცემთა ნაკადი):

ამ რეჟიმში, აპლიკაცია იყენებს SPI-ს მხოლოდ გადაცემის ან მხოლოდ მიღების რეჟიმში. / მხოლოდ გადაცემის რეჟიმი დუპლექსის რეჟიმის მსგავსია: მონაცემები გადაცემულია გადაცემის პინზე (MOSI მთავარ რეჟიმში ან MISO მონურ რეჟიმში), ხოლო მიმღები (MISO ან MOSI შესაბამისად) შეიძლება გამოყენებულ იქნას როგორც ჩვეულებრივი I/O პინი. . ამ შემთხვევაში, აპლიკაციას მხოლოდ Rx ბუფერის იგნორირება სჭირდება (თუ ის წაიკითხება, იქ არ იქნება გადაცემული მონაცემები).

შესანიშნავია, MISO პინი უფასოა, მოდით დავუკავშიროთ მას LAT სიგნალი. მოდით შევხედოთ Slave Select-ს, რომელიც STM32-ზე შეიძლება პროგრამულად კონტროლდებოდეს, რაც ძალიან მოსახერხებელია. ჩვენ ვკითხულობთ ამავე სახელწოდების აბზაცს განყოფილებაში 25.3.1 SPI ზოგადი აღწერა:

პროგრამული უზრუნველყოფის კონტროლი NSS (SSM = 1) / მონათა შერჩევის ინფორმაცია შეიცავს SPI_CR1 რეგისტრის SSI ბიტში. გარე NSS პინი თავისუფალი რჩება აპლიკაციის სხვა საჭიროებისთვის.

დროა მივწეროთ რეესტრებს. მე გადავწყვიტე გამოვიყენო SPI2, ვეძებო მისი საბაზისო მისამართი მონაცემთა ფურცელში - განყოფილებაში 3.3 Memory Map:

აბა, დავიწყოთ:

#define _SPI2_(mem_offset) (*(volatile uint32_t *)(0x40003800 + (mem_offset)))

გახსენით განყოფილება 25.3.3 თვითახსნადი სათაურით „SPI-ის კონფიგურაცია სამაგისტრო რეჟიმში“:

1. დააყენეთ სერიული საათის სიხშირე ბიტებით BR[2:0] SPI_CR1 რეგისტრში.

რეესტრები გროვდება ამავე სახელწოდების საცნობარო სახელმძღვანელოს განყოფილებაში. მისამართის ცვლა (მისამართის ოფსეტური) CR1-სთვის – 0x00, ნაგულისხმევად ყველა ბიტი გასუფთავებულია (მნიშვნელობის გადატვირთვა 0x0000):

BR ბიტი ადგენს კონტროლერის საათის გამყოფს, რითაც განსაზღვრავს სიხშირეს, რომლითაც იმუშავებს SPI. ჩვენი STM32 სიხშირე იქნება 72 MHz, LED დრაივერი, მისი მონაცემთა ცხრილის მიხედვით, მუშაობს 25 MHz-მდე სიხშირით, ამიტომ უნდა გავყოთ ოთხზე (BR[2:0] = 001).

#define _SPI_CR1 0x00

#define BR_0        0x0008
#define BR_1        0x0010
#define BR_2        0x0020

_SPI2_ (_SPI_CR1) |= BR_0;// pclk/4

2. დააყენეთ CPOL და CPHA ბიტები მონაცემთა გადაცემისა და სერიული საათის დროების კავშირის დასადგენად (იხ. დიაგრამა 240 გვერდზე)

ვინაიდან ჩვენ აქ ვკითხულობთ მონაცემთა ცხრილს და არ ვუყურებთ სქემებს, მოდით უფრო ახლოს მივხედოთ CPOL და CPHA ბიტების ტექსტის აღწერას 704 გვერდზე (SPI ზოგადი აღწერა):

საათის ფაზა და პოლარობა
SPI_CR1 რეგისტრის CPOL და CPHA ბიტების გამოყენებით, შეგიძლიათ პროგრამულად აირჩიოთ დროის ოთხი კავშირი. CPOL (საათის პოლარობის) ბიტი აკონტროლებს საათის სიგნალის მდგომარეობას, როდესაც არ ხდება მონაცემების გადაცემა. ეს ბიტი აკონტროლებს მთავარ და სლავ რეჟიმებს. თუ CPOL გადატვირთულია, SCK პინი დაბალია დასვენების რეჟიმში. თუ CPOL ბიტი დაყენებულია, SCK პინი მაღალია დასვენების რეჟიმში.
როდესაც CPHA (საათის ფაზა) ბიტი დაყენებულია, მაღალი ბიტის ხაფანგის სტრობი არის SCK სიგნალის მეორე კიდე (ვარდება თუ CPOL ნათელია, იზრდება თუ CPOL დაყენებულია). მონაცემები აღირიცხება საათის სიგნალის მეორე ცვლილებით. თუ CPHA ბიტი ნათელია, მაღალი ბიტის ტრაპის სტრობი არის SCK სიგნალის ამომავალი კიდე (ჩამოვარდნილი კიდე, თუ CPOL დაყენებულია, ამომავალი კიდე, თუ CPOL გასუფთავებულია). მონაცემები აღირიცხება საათის სიგნალის პირველივე ცვლილებისას.

ამ ცოდნის ათვისების შემდეგ მივედით დასკვნამდე, რომ ორივე ბიტი ნულებად უნდა დარჩეს, რადგან ჩვენ გვინდა, რომ SCK სიგნალი დარჩეს დაბალი, როდესაც არ გამოიყენება და მონაცემები გადაიცეს პულსის ამომავალ კიდეზე (იხ. ამომავალი ზღვარი DM634 მონაცემთა ფურცელში).

სხვათა შორის, აქ პირველად შევხვდით ST მონაცემთა ცხრილებში ლექსიკის მახასიათებელს: მათში წერია ფრაზა "ბიტის ნულზე გადატვირთვა". ცოტა გადატვირთვისთვისდა არა ცოტა გასასუფთავებლადმაგალითად, ატმეგას მსგავსად.

3. დააყენეთ DFF ბიტი იმის დასადგენად, არის თუ არა მონაცემთა ბლოკი 8-ბიტიანი თუ 16-ბიტიანი ფორმატით

მე სპეციალურად ავიღე 16-ბიტიანი DM634, რომ არ შემეწუხებინა 12-ბიტიანი PWM მონაცემების გადაცემა, როგორიცაა DM633. აზრი აქვს DFF-ის ერთზე დაყენებას:

#define DFF         0x0800

_SPI2_ (_SPI_CR1) |= DFF; // 16-bit mode

4. დააკონფიგურირეთ LSBFIRST ბიტი SPI_CR1 რეესტრში ბლოკის ფორმატის დასადგენად

LSBFIRST, როგორც მისი სახელი გვთავაზობს, ჯერ აკონფიგურირებს გადაცემას ყველაზე ნაკლებად მნიშვნელოვანი ბიტით. მაგრამ DM634 სურს მიიღოს მონაცემები დაწყებული ყველაზე მნიშვნელოვანი ბიტიდან. ამიტომ, ჩვენ ვტოვებთ მის გადატვირთვას.

5. აპარატურულ რეჟიმში, თუ საჭიროა NSS პინიდან შეყვანა, გამოიყენეთ მაღალი სიგნალი NSS პინზე მთელი ბაიტის გადაცემის თანმიმდევრობის განმავლობაში. NSS პროგრამული უზრუნველყოფის რეჟიმში დააყენეთ SSM და SSI ბიტები SPI_CR1 რეესტრში. თუ NSS პინი უნდა იქნას გამოყენებული როგორც გამოსავალი, საჭიროა მხოლოდ SSOE ბიტის დაყენება.

დააინსტალირეთ SSM და SSI, რომ დაივიწყოთ NSS აპარატურის რეჟიმი:

#define SSI         0x0100
#define SSM         0x0200

_SPI2_ (_SPI_CR1) |= SSM | SSI; //enable software control of SS, SS high

6. MSTR და SPE ბიტები უნდა იყოს დაყენებული (ისინი დაყენებულია მხოლოდ იმ შემთხვევაში, თუ NSS სიგნალი მაღალია)

სინამდვილეში, ამ ბიტებით ჩვენ ვნიშნავთ ჩვენს SPI-ს, როგორც მასტერს და ჩართავთ მას:

#define MSTR        0x0004
#define SPE         0x0040

_SPI2_ (_SPI_CR1) |= MSTR; //SPI master
//когда все готово, включаем SPI
_SPI2_ (_SPI_CR1) |= SPE;

SPI არის კონფიგურირებული, მოდით, დაუყოვნებლივ დავწეროთ ფუნქციები, რომლებიც აგზავნიან ბაიტებს დრაივერზე. განაგრძეთ კითხვა 25.3.3 „SPI-ის კონფიგურაცია სამაგისტრო რეჟიმში“:

მონაცემთა გადაცემის შეკვეთა
გადაცემა იწყება მაშინ, როდესაც ბაიტი ჩაიწერება Tx ბუფერში.
მონაცემთა ბაიტი იტვირთება shift რეესტრში at პარალელურად რეჟიმი (შიდა ავტობუსიდან) პირველი ბიტის გადაცემის დროს, რის შემდეგაც იგი გადაეცემა თანმიმდევრული MOSI პინის რეჟიმი, პირველი ან ბოლო ბიტი წინ, დამოკიდებულია LSBFIRST ბიტის პარამეტრზე CPI_CR1 რეესტრში. TXE დროშა დაყენებულია მონაცემთა გადაცემის შემდეგ Tx ბუფერიდან გადასვლის რეესტრამდედა ასევე წარმოქმნის შეფერხებას, თუ დაყენებულია TXEIE ბიტი CPI_CR1 რეესტრში.

მე ხაზგასმით აღვნიშნე თარგმანში რამდენიმე სიტყვა, რათა ყურადღება გავამახვილო STM კონტროლერებში SPI განხორციელების ერთ მახასიათებელზე. Atmega-ზე TXE დროშა (Tx ცარიელი, Tx ცარიელია და მზად არის მონაცემების მისაღებად) დაყენებულია მხოლოდ მთელი ბაიტის გაგზავნის შემდეგ გარეთ. და აქ ეს დროშა დაყენებულია მას შემდეგ, რაც ბაიტი იქნება ჩასმული შიდა shift რეესტრში. იმის გამო, რომ იგი ერთდროულად ყველა ბიტთან ერთად (პარალელურად) გადადის იქ, შემდეგ კი მონაცემები გადაიცემა თანმიმდევრულად, TXE დაყენებულია ბაიტის სრულად გაგზავნამდე. ეს მნიშვნელოვანია, რადგან ჩვენი LED დრაივერის შემთხვევაში, გაგზავნის შემდეგ LAT-ის პინი უნდა გამოვიღოთ ყველა მონაცემები, ე.ი. მხოლოდ TXE დროშა არ იქნება საკმარისი ჩვენთვის.

ეს ნიშნავს, რომ ჩვენ გვჭირდება სხვა დროშა. მოდით შევხედოთ 25.3.7 - "სტატუსის დროშები":

<...>

დაკავებული დროშა
BSY დროშა დაყენებულია და გასუფთავებულია აპარატურის მიერ (მასზე წერას არანაირი ეფექტი არ აქვს). BSY დროშა მიუთითებს SPI საკომუნიკაციო ფენის მდგომარეობაზე.
ის აღადგენს:
როდესაც გადაცემა დასრულებულია (გარდა მასტერ რეჟიმში, თუ გადაცემა უწყვეტია)
როდესაც SPI გამორთულია
როდესაც ჩნდება ძირითადი რეჟიმის შეცდომა (MODF=1)
თუ გადაცემა არ არის უწყვეტი, BSY დროშა იწმინდება თითოეულ მონაცემთა გადაცემას შორის

კარგი, ეს გამოგადგებათ. მოდით გავარკვიოთ სად მდებარეობს Tx ბუფერი. ამისათვის წაიკითხეთ "SPI მონაცემთა რეგისტრაცია":

ბიტები 15:0 DR[15:0] მონაცემთა რეგისტრაცია
მიღებული ან გადასაცემი მონაცემები.
მონაცემთა რეესტრი დაყოფილია ორ ბუფერად - ერთი ჩაწერისთვის (გადაცემის ბუფერი) და მეორე წაკითხვისთვის (მიღების ბუფერი). მონაცემთა რეესტრში ჩაწერა იწერს Tx ბუფერს, ხოლო მონაცემთა რეესტრიდან წაკითხვა დააბრუნებს მნიშვნელობას, რომელიც შეიცავს Rx ბუფერს.

და სტატუსის რეესტრი, სადაც არის TXE და BSY დროშები:

Ჩვენ ვწერთ:

#define _SPI_DR  0x0C
#define _SPI_SR  0x08

#define BSY         0x0080
#define TXE         0x0002

void dm_shift16(uint16_t value)
{
    _SPI2_(_SPI_DR) = value; //send 2 bytes
    while (!(_SPI2_(_SPI_SR) & TXE)); //wait until they're sent
}

კარგი, რადგან ჩვენ გვჭირდება 16-ჯერ ორი ბაიტის გადაცემა, LED დრაივერის გამომავალი რაოდენობის მიხედვით, დაახლოებით ასეთი:

void sendLEDdata()
{
    LAT_low();
    uint8_t k = 16;
    do
    {   k--;
        dm_shift16(leds[k]);
    } while (k);

    while (_SPI2_(_SPI_SR) & BSY); // finish transmission

    LAT_pulse();
}

მაგრამ ჩვენ ჯერ არ ვიცით, როგორ გავიყვანოთ LAT პინი, ამიტომ დავუბრუნდებით I/O-ს.

ქინძისთავების მინიჭება

STM32F1-ში, ქინძისთავების მდგომარეობაზე პასუხისმგებელი რეგისტრები საკმაოდ უჩვეულოა. გასაგებია, რომ ისინი უფრო მეტია ვიდრე Atmega, მაგრამ ისინი ასევე განსხვავდებიან სხვა STM ჩიპებისგან. ნაწილი 9.1 GPIO-ს ზოგადი აღწერა:

თითოეული ზოგადი დანიშნულების I/O პორტი (GPIO) აქვს ორი 32-ბიტიანი კონფიგურაციის რეგისტრი (GPIOx_CRL და GPIOx_CRH), ორი 32-ბიტიანი მონაცემთა რეგისტრი (GPIOx_IDR და GPIOx_ODR), 32-ბიტიანი დაყენების/გადატვირთვის რეგისტრი (GPIOx_BSRR), 16-ბიტიანი გადატვირთვის რეგისტრი (GPIOx_BRR) და ბიტის დაბლოკვის რეგისტრი (GPIOx_LCKR).

პირველი ორი რეგისტრი უჩვეულოა და ასევე საკმაოდ მოუხერხებელია, რადგან 16 პორტის პინი მიმოფანტულია მათზე "ოთხი ბიტი ძმაზე" ფორმატში. იმათ. ქინძისთავები ნულიდან შვიდამდე არის CRL-ში, დანარჩენი კი CRH-ში. ამავდროულად, დარჩენილი რეგისტრები წარმატებით შეიცავს პორტის ყველა პინის ბიტებს - ხშირად რჩება ნახევრად "რეზერვირებული".

სიმარტივისთვის, დავიწყოთ სიის ბოლოდან.

ჩვენ არ გვჭირდება დაბლოკვის რეესტრი.

დაყენება და გადატვირთვის რეგისტრები საკმაოდ სასაცილოა იმით, რომ ისინი ნაწილობრივ იმეორებენ ერთმანეთს: შეგიძლიათ დაწეროთ ყველაფერი მხოლოდ BSRR-ში, სადაც 16 უფრო მაღალი ბიტი აღადგენს პინს ნულზე, ხოლო ქვედა დაყენდება 1-ზე, ან ასევე შეგიძლიათ. გამოიყენეთ BRR, რომლის ქვედა 16 ბიტი მხოლოდ პინი გადააყენეთ. მეორე ვარიანტი მომწონს. ეს რეგისტრები მნიშვნელოვანია, რადგან ისინი უზრუნველყოფენ ატომურ წვდომას ქინძისთავებზე:

ატომური კომპლექტი ან გადატვირთვა
არ არის საჭირო შეფერხებების გამორთვა GPIOx_ODR-ის დაპროგრამებისას ბიტის დონეზე: ერთი ან მეტი ბიტი შეიძლება შეიცვალოს ერთი ატომური ჩაწერის ოპერაციით APB2. ეს მიიღწევა "1"-ის ჩაწერით დაყენების/გადატვირთვის რეესტრში (GPIOx_BSRR ან, მხოლოდ გადატვირთვისთვის, GPIOx_BRR) იმ ბიტის, რომელიც უნდა შეიცვალოს. სხვა ბიტები უცვლელი დარჩება.

მონაცემთა რეგისტრებს აქვთ საკმაოდ გასაგები სახელები - IDR = შეყვანის მიმართულების რეესტრი, შეყვანის რეგისტრი; ODR = გამოყვანის მიმართულების რეგისტრი, გამომავალი რეგისტრი. ისინი არ დაგვჭირდება მიმდინარე პროექტში.

და ბოლოს, საკონტროლო რეგისტრები. ვინაიდან ჩვენ გვაინტერესებს მეორე SPI ქინძისთავები, კერძოდ PB13, PB14 და PB15, ჩვენ დაუყოვნებლივ ვუყურებთ CRH-ს:

და ჩვენ ვხედავთ, რომ დაგვჭირდება რაღაცის ჩაწერა ბიტებში 20-დან 31-მდე.

ზემოთ უკვე გავარკვიეთ რა გვინდა ქინძისთავებისაგან, ამიტომ აქ გავაკეთებ სკრინშოტის გარეშე, უბრალოდ ვიტყვი, რომ MODE განსაზღვრავს მიმართულებას (შეყვანა თუ ორივე ბიტი დაყენებულია 0-ზე) და პინის სიჩქარე (გვჭირდება 50 MHz, ე.ი. ორივე პინი „1“-ზე), და CNF აყენებს რეჟიმს: რეგულარული „დაძაბვა“ – 00, „ალტერნატივა“ – 10. ნაგულისხმევად, როგორც ზემოთ ვხედავთ, ყველა პინს აქვს მესამე ბიტი ქვემოდან (CNF0). ის აყენებს მათ რეჟიმში მცურავი შეყვანა.

ვინაიდან ამ ჩიპით სხვა რამის გაკეთებას ვაპირებ, სიმარტივისთვის მე განვსაზღვრე ყველა შესაძლო MODE და CNF მნიშვნელობა როგორც ქვედა, ასევე ზედა საკონტროლო რეგისტრებისთვის.

რატომღაც ასე

#define CNF0_0 0x00000004
#define CNF0_1 0x00000008
#define CNF1_0 0x00000040
#define CNF1_1 0x00000080
#define CNF2_0 0x00000400
#define CNF2_1 0x00000800
#define CNF3_0 0x00004000
#define CNF3_1 0x00008000
#define CNF4_0 0x00040000
#define CNF4_1 0x00080000
#define CNF5_0 0x00400000
#define CNF5_1 0x00800000
#define CNF6_0 0x04000000
#define CNF6_1 0x08000000
#define CNF7_0 0x40000000
#define CNF7_1 0x80000000
#define CNF8_0 0x00000004
#define CNF8_1 0x00000008
#define CNF9_0 0x00000040
#define CNF9_1 0x00000080
#define CNF10_0 0x00000400
#define CNF10_1 0x00000800
#define CNF11_0 0x00004000
#define CNF11_1 0x00008000
#define CNF12_0 0x00040000
#define CNF12_1 0x00080000
#define CNF13_0 0x00400000
#define CNF13_1 0x00800000
#define CNF14_0 0x04000000
#define CNF14_1 0x08000000
#define CNF15_0 0x40000000
#define CNF15_1 0x80000000

#define MODE0_0 0x00000001
#define MODE0_1 0x00000002
#define MODE1_0 0x00000010
#define MODE1_1 0x00000020
#define MODE2_0 0x00000100
#define MODE2_1 0x00000200
#define MODE3_0 0x00001000
#define MODE3_1 0x00002000
#define MODE4_0 0x00010000
#define MODE4_1 0x00020000
#define MODE5_0 0x00100000
#define MODE5_1 0x00200000
#define MODE6_0 0x01000000
#define MODE6_1 0x02000000
#define MODE7_0 0x10000000
#define MODE7_1 0x20000000
#define MODE8_0 0x00000001
#define MODE8_1 0x00000002
#define MODE9_0 0x00000010
#define MODE9_1 0x00000020
#define MODE10_0 0x00000100
#define MODE10_1 0x00000200
#define MODE11_0 0x00001000
#define MODE11_1 0x00002000
#define MODE12_0 0x00010000
#define MODE12_1 0x00020000
#define MODE13_0 0x00100000
#define MODE13_1 0x00200000
#define MODE14_0 0x01000000
#define MODE14_1 0x02000000
#define MODE15_0 0x10000000
#define MODE15_1 0x20000000

ჩვენი პინები მდებარეობს B პორტზე (ბაზის მისამართი – 0x40010C00), კოდი:

#define _PORTB_(mem_offset) (*(volatile uint32_t *)(0x40010C00 + (mem_offset)))

#define _BRR  0x14
#define _BSRR 0x10
#define _CRL  0x00
#define _CRH  0x04

//используем стандартный SPI2: MOSI на B15, CLK на B13
//LAT пусть будет на неиспользуемом MISO – B14

//очищаем дефолтный бит, он нам точно не нужен
_PORTB_ (_CRH) &= ~(CNF15_0 | CNF14_0 | CNF13_0 | CNF12_0);

//альтернативные функции для MOSI и SCK
_PORTB_ (_CRH) |= CNF15_1 | CNF13_1;

//50 МГц, MODE = 11
_PORTB_ (_CRH) |= MODE15_1 | MODE15_0 | MODE14_1 | MODE14_0 | MODE13_1 | MODE13_0;

და, შესაბამისად, შეგიძლიათ დაწეროთ განმარტებები LAT-ისთვის, რომლებიც გადაიჭრება BRR და BSRR რეგისტრებით:

/*** LAT pulse – high, then low */
#define LAT_pulse() _PORTB_(_BSRR) = (1<<14); _PORTB_(_BRR) = (1<<14)

#define LAT_low() _PORTB_(_BRR) = (1<<14)

(LAT_low მხოლოდ ინერციით, ყოველთვის ასე იყო, დარჩეს)

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

ჩართეთ დათქმა

საათი, რომელიც ასევე ცნობილია როგორც საათი, პასუხისმგებელია საათზე. და ჩვენ უკვე შევამჩნიეთ აბრევიატურა RCC. ჩვენ ვეძებთ მას დოკუმენტაციაში: ეს არის გადატვირთვა და საათის კონტროლი.

როგორც ზემოთ ითქვა, საბედნიეროდ, ქრონიკის თემის ურთულესი ნაწილი გაგვიკეთეს STM-ის ადამიანებმა, რისთვისაც მათ დიდ მადლობას ვუხდით (კიდევ ერთხელ მივცემ ლინკს დი ჰალტის ვებსაიტზე, იმის გასაგებად, თუ რამდენად დამაბნეველია). ჩვენ გვჭირდება მხოლოდ რეგისტრები, რომლებიც პასუხისმგებელნი არიან პერიფერიული დაკვრის ჩართვაზე (Peripheral Clock Enable Registers). პირველი, მოდით ვიპოვოთ RCC-ის საბაზისო მისამართი, ის არის "მეხსიერების რუქის" დასაწყისში:

#define _RCC_(mem_offset) (*(volatile uint32_t *)(0x40021000 + (mem_offset)))

და შემდეგ ან დააწკაპუნეთ ბმულზე, სადაც ცდილობთ რაიმეს პოვნას ფირფიტაში, ან, ბევრად უკეთესი, გადახედეთ გამაძლიერებელი რეგისტრების აღწერილობებს განყოფილებებიდან. რეგისტრების ჩართვა. სად ვიპოვით RCC_APB1ENR და RCC_APB2ENR:

და ისინი, შესაბამისად, შეიცავს ბიტებს, რომლებიც მოიცავს SPI2, IOPB (I/O პორტი B) და ალტერნატიულ ფუნქციებს (AFIO).

#define _APB2ENR 0x18
#define _APB1ENR 0x1C

#define IOPBEN 0x0008
#define SPI2EN 0x4000
#define AFIOEN 0x0001

//включаем тактирование порта B и альт. функций
_RCC_(_APB2ENR) |= IOPBEN | AFIOEN;

//включаем  тактирование SPI2
_RCC_(_APB1ENR) |= SPI2EN;

საბოლოო კოდი შეგიძლიათ იხილოთ აქ.

თუ თქვენ გაქვთ ტესტირების შესაძლებლობა და სურვილი, მაშინ შეაერთეთ DM634 ასე: DAI PB15-ზე, DCK-ზე PB13-ზე, LAT-ზე PB14-ზე. დრაივერს ვაძლევთ 5 ვოლტიდან, არ დაგავიწყდეთ საფუძვლების დაკავშირება.

STM8 PWM

PWM STM8-ზე

როდესაც ახლახან ვგეგმავდი ამ სტატიას, გადავწყვიტე, მაგალითად, შემესწავლა უცნობი ჩიპის გარკვეული ფუნქციონირება მხოლოდ მონაცემთა ფურცლის გამოყენებით, რათა არ დამემთავრებინა ფეხსაცმლის მწარმოებელი ჩექმების გარეშე. STM8 იდეალური იყო ამ როლისთვის: ჯერ ერთი, მე მქონდა რამდენიმე ჩინური დაფა STM8S103-ით და მეორეც, ის არც თუ ისე პოპულარულია და, შესაბამისად, ინტერნეტში წაკითხვისა და გამოსავლის პოვნის ცდუნება სწორედ ამ გადაწყვეტილებების ნაკლებობას ეყრდნობა.

ჩიპსაც აქვს მონაცემთა ფურცელი и საცნობარო სახელმძღვანელო RM0016, პირველში არის pinout და რეგისტრაციის მისამართები, მეორეში - ყველაფერი დანარჩენი. STM8 დაპროგრამებულია C-ზე საშინელ IDE-ში ST Visual Develop.

Clocking და I/O

ნაგულისხმევად, STM8 მუშაობს 2 MHz სიხშირეზე, ეს დაუყოვნებლივ უნდა გამოსწორდეს.

HSI (მაღალი სიჩქარის შიდა) საათი
HSI საათის სიგნალი მიღებულია შიდა 16 MHz RC ოსცილატორიდან პროგრამირებადი გამყოფით (1-დან 8-მდე). ის დაყენებულია საათის გამყოფ რეესტრში (CLK_CKDIVR).
შენიშვნა: დასაწყისში, HSI RC ოსცილატორი 8-ის გამყოფით არჩეულია საათის სიგნალის წამყვან წყაროდ.

ჩვენ ვპოულობთ რეესტრის მისამართს მონაცემთა ფურცელში, აღწერას refman-ში და ვხედავთ, რომ რეესტრი უნდა გასუფთავდეს:

#define CLK_CKDIVR *(volatile uint8_t *)0x0050C6

CLK_CKDIVR &= ~(0x18);

იმის გამო, რომ ჩვენ ვაპირებთ PWM-ს გაშვებას და LED-ების დაკავშირებას, მოდით გადავხედოთ პინუტს:

ჩიპი არის პატარა, ბევრი ფუნქცია შეჩერებულია იმავე ქინძისთავებზე. ის, რაც კვადრატულ ფრჩხილებშია, არის „ალტერნატიული ფუნქციონირება“, ის გადართულია „ოფციონ ბაიტით“ (ვარიანტის ბაიტები) – რაღაც ატმეგას დაუკრავენ. თქვენ შეგიძლიათ შეცვალოთ მათი მნიშვნელობები პროგრამულად, მაგრამ ეს არ არის აუცილებელი, რადგან ახალი ფუნქცია გააქტიურებულია მხოლოდ გადატვირთვის შემდეგ. უფრო ადვილია ST Visual Programmer-ის გამოყენება (ჩამოტვირთულია Visual Develop-ით), რომელსაც შეუძლია შეცვალოს ეს ბაიტები. პინოტი აჩვენებს, რომ პირველი ტაიმერის CH1 და CH2 ქინძისთავები დამალულია კვადრატულ ფრჩხილებში; აუცილებელია AFR1 და AFR0 ბიტების დაყენება STVP-ში, ხოლო მეორე ასევე გადასცემს მეორე ტაიმერის CH1 გამომავალს PD4-დან PC5-ზე.

ამრიგად, 6 ქინძისთავი გააკონტროლებს LED-ებს: PC6, PC7 და PC3 პირველი ტაიმერი, PC5, PD3 და PA3 მეორეში.

I/O პინების დაყენება STM8-ზე უფრო მარტივი და ლოგიკურია, ვიდრე STM32-ზე:

ნაცნობი Atmega DDR მონაცემთა მიმართულების რეესტრიდან (მონაცემთა მიმართულების რეგისტრაცია): 1 = გამომავალი;
პირველი საკონტროლო რეგისტრი CR1, როდესაც გამოდის, აყენებს ბიძგ-გაყვანის რეჟიმს (1) ან ღია გადინებას (0); რადგან LED-ებს ჩიპს კათოდებით ვუკავშირებ, აქ ნულებს ვტოვებ;
მეორე საკონტროლო რეგისტრი CR2, როდესაც გამოდის, ადგენს საათის სიჩქარეს: 1 = 10 MHz

#define PA_DDR     *(volatile uint8_t *)0x005002
#define PA_CR2     *(volatile uint8_t *)0x005004
#define PD_DDR     *(volatile uint8_t *)0x005011
#define PD_CR2     *(volatile uint8_t *)0x005013
#define PC_DDR     *(volatile uint8_t *)0x00500C
#define PC_CR2     *(volatile uint8_t *)0x00500E

PA_DDR = (1<<3); //output
PA_CR2 |= (1<<3); //fast
PD_DDR = (1<<3); //output
PD_CR2 |= (1<<3); //fast
PC_DDR = ((1<<3) | (1<<5) | (1<<6) | (1<<7)); //output
PC_CR2 |= ((1<<3) | (1<<5) | (1<<6) | (1<<7)); //fast

PWM პარამეტრი

პირველ რიგში, მოდით განვსაზღვროთ ტერმინები:

PWM სიხშირე - სიხშირე, რომლითაც ტაიმერი იკლებს;
ავტომატური გადატვირთვა, AR – ავტომატური ჩატვირთვადი მნიშვნელობა, რომელზედაც დაითვლება ტაიმერი (პულსის პერიოდი);
ღონისძიების განახლება, UEV – მოვლენა, რომელიც ხდება, როდესაც ტაიმერი დათვლის AR-მდე;
PWM სამუშაო ციკლი - PWM სამუშაო ციკლი, რომელსაც ხშირად უწოდებენ "მორიგე ფაქტორს";
ღირებულების აღება/შედარება – მნიშვნელობა აღბეჭდვის/შედარებისთვის, რომელსაც ითვლის ტაიმერი რამეს გააკეთებს (PWM-ის შემთხვევაში ის აბრუნებს გამომავალ სიგნალს);
წინასწარ ჩატვირთვის მნიშვნელობა - წინასწარ დატვირთული მნიშვნელობა. შეადარეთ ღირებულება ვერ შეიცვლება, სანამ ტაიმერი იკეცება, წინააღმდეგ შემთხვევაში PWM ციკლი იშლება. ამიტომ, ახალი გადაცემული მნიშვნელობები მოთავსებულია ბუფერში და ამოღებულია, როდესაც ტაიმერი მიაღწევს ათვლის დასასრულს და აღდგება;
კიდეზე გასწორებული и ცენტრში გასწორებული რეჟიმები - გასწორება საზღვრის გასწვრივ და ცენტრში, იგივე ატმელის სწრაფი PWM и ფაზის სწორი PWM.
OCiREF, გამომავალი შედარების საცნობარო სიგნალი – საცნობარო გამომავალი სიგნალი, ფაქტობრივად, ის, რაც ჩნდება შესაბამის პინზე PWM რეჟიმში.

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

PWM-ს STM8-ზე აქვს მნიშვნელოვანი უპირატესობა PWM-ზე Atmega-ზე:

საზღვრის გასწორებული PWM
ანგარიშის კონფიგურაცია ქვემოდან ზემოდან
ქვემოდან ზემოთ დათვლა აქტიურია, თუ TIM_CR1 რეესტრში DIR ბიტი გასუფთავებულია
მაგალითი
მაგალითი იყენებს პირველ PWM რეჟიმს. PWM საცნობარო სიგნალი OCiREF ინახება მანამ, სანამ TIM1_CNT < TIM1_CCRi. წინააღმდეგ შემთხვევაში დაბალ დონეს იღებს. თუ შედარების მნიშვნელობა TIM1_CCRi რეგისტრში მეტია ავტომატური დატვირთვის მნიშვნელობაზე (TIM1_ARR რეგისტრი), OCiREF სიგნალი ინახება 1-ზე. თუ შედარების მნიშვნელობა არის 0, OCiREF ინახება ნულზე....

STM8 ტაიმერი დროს ღონისძიების განახლება ჯერ ამოწმებს შეადარეთ ღირებულებადა მხოლოდ ამის შემდეგ გამოიმუშავებს საცნობარო სიგნალს. ატმეგას ტაიმერი ჯერ ხრახნის და მერე ადარებს, რის შედეგადაც compare value == 0 გამომავალი არის ნემსი, რომელსაც როგორმე უნდა მოგვარდეს (მაგალითად, ლოგიკის პროგრამულად შებრუნებით).

რისი გაკეთება გვინდა: 8-ბიტიანი PWM (AR == 255), დათვლა ქვემოდან ზევით, გასწორება საზღვრის გასწვრივ. ვინაიდან ნათურები დაკავშირებულია ჩიპთან კათოდებით, PWM უნდა გამოსცეს 0 (LED ჩართული), სანამ შეადარეთ ღირებულება და 1 შემდეგ.

ზოგიერთის შესახებ უკვე წავიკითხეთ PWM რეჟიმი, ასე რომ, ჩვენ ვპოულობთ მეორე ტაიმერის საჭირო რეესტრს ამ ფრაზის საცნობარო სახელმძღვანელოში მოძიებით (18.6.8 - TIMx_CCMR1):

110: პირველი PWM რეჟიმი – ქვემოდან ზევით დათვლისას, პირველი არხი აქტიურია, ხოლო TIMx_CNT < TIMx_CCR1. წინააღმდეგ შემთხვევაში, პირველი არხი უმოქმედოა. [შემდეგ დოკუმენტში არის მცდარი კოპირ-პასტი ტაიმერი 1-დან] 111: მეორე PWM რეჟიმი – ქვემოდან ზევით დათვლისას პირველი არხი უმოქმედოა, ხოლო TIMx_CNT < TIMx_CCR1. წინააღმდეგ შემთხვევაში, პირველი არხი აქტიურია.

ვინაიდან LED-ები MK-ს კათოდებით უკავშირდება, მეორე რეჟიმი გვიწყობს (პირველიც, მაგრამ ეს ჯერ არ ვიცით).

ბიტი 3 OC1PE: ჩართეთ პინი 1 წინასწარ ჩატვირთვა
0: TIMx_CCR1-ზე წინასწარ ჩატვირთვის რეგისტრაცია გამორთულია. შეგიძლიათ დაწეროთ TIMx_CCR1 ნებისმიერ დროს. ახალი ღირებულება მუშაობს დაუყოვნებლივ.
1: ჩართულია წინასწარ ჩატვირთვის რეგისტრაცია TIMx_CCR1-ზე. წაკითხვის/ჩაწერის ოპერაციების წვდომა წინასწარ ჩატვირთვის რეესტრში. წინასწარ დატვირთული მნიშვნელობა TIMx_CCR1 იტვირთება ჩრდილის რეესტრში ყოველი განახლების მოვლენის დროს.
*შენიშვნა: იმისათვის, რომ PWM რეჟიმი გამართულად იმუშაოს, წინასწარ ჩატვირთვის რეგისტრები უნდა იყოს ჩართული. ეს არ არის აუცილებელი ერთი სიგნალის რეჟიმში (OPM ბიტი დაყენებულია TIMx_CR1 რეესტრში).

კარგი, მოდით ჩავრთოთ ყველაფერი, რაც გვჭირდება მეორე ტაიმერის სამი არხისთვის:

#define TIM2_CCMR1 *(volatile uint8_t *)0x005307
#define TIM2_CCMR2 *(volatile uint8_t *)0x005308
#define TIM2_CCMR3 *(volatile uint8_t *)0x005309

#define PWM_MODE2   0x70 //PWM mode 2, 0b01110000
#define OCxPE       0x08 //preload enable

TIM2_CCMR1 = (PWM_MODE2 | OCxPE);
TIM2_CCMR2 = (PWM_MODE2 | OCxPE);
TIM2_CCMR3 = (PWM_MODE2 | OCxPE);

AR შედგება ორი რვა ბიტიანი რეგისტრისგან, ყველაფერი მარტივია:

#define TIM2_ARRH  *(volatile uint8_t *)0x00530F
#define TIM2_ARRL  *(volatile uint8_t *)0x005310

TIM2_ARRH = 0;
TIM2_ARRL = 255;

მეორე ტაიმერს შეუძლია მხოლოდ ქვემოდან ზემოდან დათვლა, გასწორება საზღვრის გასწვრივ, არაფერი უნდა შეიცვალოს. მოდით დავაყენოთ სიხშირის გამყოფი, მაგალითად, 256-ზე. მეორე ტაიმერისთვის, გამყოფი დაყენებულია TIM2_PSCR რეესტრში და არის ორი სიმძლავრე:

#define TIM2_PSCR  *(volatile uint8_t *)0x00530E

TIM2_PSCR = 8;

რჩება მხოლოდ დასკვნების ჩართვა და თავად მეორე ტაიმერი. პირველი პრობლემა მოგვარებულია რეგისტრებით გადაღება/შედარება ჩართვა: მათზე ასიმეტრიულად მიმოფანტულია ორი, სამი არხი. აქვე შეგვიძლია გავიგოთ, რომ შესაძლებელია სიგნალის პოლარობის შეცვლა, ე.ი. პრინციპში შესაძლებელი იყო PWM რეჟიმი 1-ის გამოყენება. ჩვენ ვწერთ:

#define TIM2_CCER1 *(volatile uint8_t *)0x00530A
#define TIM2_CCER2 *(volatile uint8_t *)0x00530B

#define CC1E  (1<<0) // CCER1
#define CC2E  (1<<4) // CCER1
#define CC3E  (1<<0) // CCER2

TIM2_CCER1 = (CC1E | CC2E);
TIM2_CCER2 = CC3E;

და ბოლოს, ჩვენ ვიწყებთ ტაიმერს TIMx_CR1 რეესტრში:

#define TIM2_CR1   *(volatile uint8_t *)0x005300

TIM2_CR1 |= 1;

მოდით დავწეროთ AnalogWrite(-ის მარტივი ანალოგი), რომელიც გადასცემს რეალურ მნიშვნელობებს ტაიმერს შედარებისთვის. რეგისტრები დასახელებულია პროგნოზირებულად რეგისტრების აღება/შედარებათითოეული არხისთვის არის ორი მათგანი: დაბალი რიგის 8 ბიტი TIM2_CCRxL-ში და მაღალი რიგის TIM2_CCRxH. ვინაიდან ჩვენ შევქმენით 8-ბიტიანი PWM, საკმარისია ჩაწეროთ მხოლოდ ყველაზე ნაკლებად მნიშვნელოვანი ბიტები:

#define TIM2_CCR1L *(volatile uint8_t *)0x005312
#define TIM2_CCR2L *(volatile uint8_t *)0x005314
#define TIM2_CCR3L *(volatile uint8_t *)0x005316

void setRGBled(uint8_t r, uint8_t g, uint8_t b)
{
    TIM2_CCR1L = r;
    TIM2_CCR2L = g;
    TIM2_CCR3L = b;
}

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

მეორე ტაიმერზე PWM მუშაობს, მოდით გადავიდეთ პირველზე.

პირველ ტაიმერს აქვს ზუსტად იგივე ბიტები იმავე რეესტრებში (უბრალოდ ის ბიტები, რომლებიც დარჩა "რეზერვირებული" მეორე ტაიმერში, პირველში აქტიურად გამოიყენება ყველა სახის მოწინავე ნივთებისთვის). ამიტომ საკმარისია მონაცემთა ფურცელში იმავე რეგისტრების მისამართების მოძიება და კოდის კოპირება. შეცვალეთ სიხშირის გამყოფის მნიშვნელობა, რადგან... პირველ ტაიმერს სურს მიიღოს არა ორი, არამედ ზუსტი 16-ბიტიანი მნიშვნელობა ორ რეესტრში Prescaler მაღალი и დაბალი. ყველაფერს ვაკეთებთ და... პირველი ტაიმერი არ მუშაობს. Რა მოხდა?

პრობლემის გადაჭრა შესაძლებელია მხოლოდ 1-ის ტაიმერის საკონტროლო რეგისტრების მთელი განყოფილების გადახედვით, სადაც ვეძებთ მას, რომელიც მეორე ტაიმერს არ აქვს. Იქ იქნება 17.7.30 შესვენების რეგისტრაცია (TIM1_BKR), სადაც არის ეს ბიტი:

ძირითადი გამომავალი ჩართვა

#define TIM1_BKR   *(volatile uint8_t *)0x00526D

TIM1_BKR = (1<<7);

ეს ყველაფერი დარწმუნებულია ახლა, კოდი იმავე ადგილას.

STM8 Multiplex

მულტიპლექსირება STM8-ზე

მესამე მინი-პროექტი არის რვა RGB LED-ის დაკავშირება მეორე ტაიმერთან PWM რეჟიმში და მათ სხვადასხვა ფერის ჩვენება. იგი დაფუძნებულია LED მულტიპლექსირების კონცეფციაზე, რომელიც არის ის, რომ თუ თქვენ ჩართავთ და გამორთავთ LED-ებს ძალიან, ძალიან სწრაფად, გვეჩვენება, რომ ისინი მუდმივად ჩართულია (ხედვის არსებობა, ვიზუალური აღქმის ინერცია). ერთხელ გავაკეთე რაღაც მსგავსი Arduino-ზე.

მუშაობის ალგორითმი ასე გამოიყურება:

დააკავშირეთ პირველი RGB LED-ის ანოდი;
აანთო იგი, აგზავნის საჭირო სიგნალებს კათოდებზე;
დაელოდა PWM ციკლის დასრულებას;
დააკავშირეთ მეორე RGB LED-ის ანოდი;
აანთო...

ისე და ა.შ. რა თქმა უნდა, ლამაზი მუშაობისთვის საჭიროა ანოდის მიერთება და შუქდიოდის „ანთება“ ერთდროულად. კარგად, ან თითქმის. ნებისმიერ შემთხვევაში, ჩვენ უნდა დავწეროთ კოდი, რომელიც გამოსცემს მნიშვნელობებს მეორე ტაიმერის სამ არხში, შევცვლით მათ UEV მიღწევისას და ამავდროულად შევცვლით ამჟამად აქტიურ RGB LED-ს.

ვინაიდან LED გადართვა ავტომატურია, ჩვენ უნდა შევქმნათ „ვიდეო მეხსიერება“, საიდანაც შეფერხების დამმუშავებელი მიიღებს მონაცემებს. ეს არის მარტივი მასივი:

uint8_t colors[8][3];

კონკრეტული LED-ის ფერის შესაცვლელად საკმარისი იქნება ამ მასივში საჭირო მნიშვნელობების ჩაწერა. და ცვლადი პასუხისმგებელია აქტიური LED- ის რაოდენობაზე

uint8_t cnt;

დემუქსი

სათანადო მულტიპლექსირებისთვის, ჩვენ გვჭირდება, უცნაურად საკმარისი, CD74HC238 დემულტიპლექსერი. დემულტიპლექსერი - ჩიპი, რომელიც ახორციელებს ოპერატორს აპარატურაში <<. სამი შეყვანის პინის მეშვეობით (ბიტი 0, 1 და 2) ჩვენ ვაძლევთ მას სამ ბიტიან X რიცხვს და საპასუხოდ ის ააქტიურებს გამომავალ ნომერს (1<<X). ჩიპის დარჩენილი შენატანები გამოიყენება მთლიანი დიზაინის გასაზომად. ჩვენ გვჭირდება ეს ჩიპი არა მხოლოდ მიკროკონტროლერის დაკავებული ქინძისთავების რაოდენობის შესამცირებლად, არამედ უსაფრთხოებისთვის - ისე, რომ შემთხვევით არ ჩართოთ მეტი LED-ები, ვიდრე შესაძლებელია და არ დაწვათ MK. ჩიპი ღირს ერთი პენი და ყოველთვის უნდა ინახებოდეს თქვენს სახლში მედიცინის კაბინეტში.

ჩვენი CD74HC238 იქნება პასუხისმგებელი ძაბვის მიწოდებაზე სასურველი LED-ის ანოდზე. სრულფასოვან მულტიპლექსში ის ძაბვას აწვდის სვეტს P-MOSFET-ის საშუალებით, მაგრამ ამ დემოში ეს შესაძლებელია პირდაპირ, რადგან იგი ამახვილებს 20 mA-ს, შესაბამისად აბსოლუტური მაქსიმალური რეიტინგები მონაცემთა ფურცელში. დან მონაცემთა ფურცელი CD74HC238 ჩვენ გვჭირდება pinouts და ეს მოტყუების ფურცელი:

H = მაღალი ძაბვის დონე, L = დაბალი ძაბვის დონე, X - არ მაინტერესებს

ჩვენ ვუკავშირდებით E2 და E1 მიწას, E3, A0, A1 და A3 ქინძისთავებს PD5, PC3, PC4 და PC5 STM8. ვინაიდან ზემოთ მოცემული ცხრილი შეიცავს როგორც დაბალ, ასევე მაღალ დონეებს, ჩვენ ვაკონფიგურირებთ ამ ქინძისთავებს, როგორც Push-pull pins.

PWM

მეორე ტაიმერზე PWM კონფიგურირებულია ისევე, როგორც წინა ისტორიაში, ორი განსხვავებით:

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

შეწყვეტის ჩართვის რეგისტრაცია

#define TIM2_IER   *(volatile uint8_t *)0x005303

//enable interrupt
TIM2_IER = 1;

მეორე განსხვავება დაკავშირებულია მულტიპლექსირების ფენომენთან, მაგ ghosting - დიოდების პარაზიტული ბზინვარება. ჩვენს შემთხვევაში, ეს შეიძლება გამოჩნდეს იმის გამო, რომ ტაიმერი, რომელმაც UEV-ზე შეფერხება გამოიწვია, აგრძელებს მონიშვნას, ხოლო შეფერხების დამმუშავებელს არ აქვს დრო, გადართოს LED, სანამ ტაიმერი დაიწყებს რაიმეს დაწერას ქინძისთავებზე. ამის წინააღმდეგ საბრძოლველად, თქვენ მოგიწევთ ლოგიკის შებრუნება (0 = მაქსიმალური სიკაშკაშე, 255 = არაფერია განათებული) და თავიდან აიცილოთ ექსტრემალური სამუშაო ციკლის მნიშვნელობები. იმათ. დარწმუნდით, რომ UEV-ის შემდეგ LED-ები მთლიანად ჩაქრება ერთი PWM ციკლისთვის.

პოლარობის შეცვლა:

//set polarity 
    TIM2_CCER1 |= (CC1P | CC2P);
    TIM2_CCER2 |= CC3P;

მოერიდეთ r, g და b 255-ზე დაყენებას და დაიმახსოვრეთ მათი გამოყენებისას მათი ინვერსია.

წყვეტს

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

როდესაც ჩვენ პირველად შევქმენით პროექტი ST Visual Develop-ში, გარდა ამისა main.c მივიღეთ ფანჯარა იდუმალი ფაილით stm8_interrupt_vector.c, ავტომატურად შედის პროექტში. ამ ფაილში ფუნქცია ენიჭება თითოეულ შეწყვეტას NonHandledInterrupt. ჩვენ უნდა დავაკავშიროთ ჩვენი ფუნქცია სასურველ შეწყვეტასთან.

მონაცემთა ფურცელს აქვს შეფერხების ვექტორების ცხრილი, სადაც ვპოულობთ ჩვენ გვჭირდება:

13 TIM2 განახლება/გადინება
14 TIM2 გადაღება/შედარება

ჩვენ გვჭირდება LED-ის შეცვლა UEV-ზე, ამიტომ გვჭირდება შეწყვეტა #13.

შესაბამისად, პირველ რიგში, ფაილში stm8_interrupt_vector.c შეცვალეთ ფუნქციის ნაგულისხმევი სახელი, რომელიც პასუხისმგებელია No13 შეფერხებაზე (IRQ13) თქვენით:

{0x82, TIM2_Overflow}, /* irq13 */

მეორეც, ჩვენ მოგვიწევს ფაილის შექმნა main.h შემდეგი შინაარსით:

#ifndef __MAIN_H
#define __MAIN_H

@far @interrupt void TIM2_Overflow (void);
#endif

და ბოლოს, ჩაწერეთ ეს ფუნქცია თქვენსში main.c:

@far @interrupt void TIM2_Overflow (void)
{
    PD_ODR &= ~(1<<5); // вырубаем демультиплексор
    PC_ODR = (cnt<<3); // записываем в демультиплексор новое значение
    PD_ODR |= (1<<5); // включаем демультиплексор

    TIM2_SR1 = 0; // сбрасываем флаг Update Interrupt Pending

    cnt++; 
    cnt &= 7; // двигаем счетчик LED

    TIM2_CCR1L = ~colors[cnt][0]; // передаем в буфер инвертированные значения
    TIM2_CCR2L = ~colors[cnt][1]; // для следующего цикла ШИМ
    TIM2_CCR3L = ~colors[cnt][2]; // 

    return;
}

რჩება მხოლოდ შეფერხებების ჩართვა. ეს კეთდება ასამბლერის ბრძანების გამოყენებით rim -შენ მოგიწევს მისი ძებნა პროგრამირების სახელმძღვანელო:

//enable interrupts
_asm("rim");

ასამბლერის კიდევ ერთი ბრძანებაა sim – თიშავს წყვეტებს. ისინი უნდა გამორთოთ, სანამ ახალი მნიშვნელობები იწერება "ვიდეო მეხსიერებაში", რათა არასწორ მომენტში გამოწვეულმა შეფერხებამ არ გააფუჭოს მასივი.

ყველა კოდი - GitHub-ზე.

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

წყარო: www.habr.com

წაიკითხეთ მონაცემთა ცხრილები 2: SPI STM32-ზე; PWM, ტაიმერები და შეფერხებები STM8-ზე

STM32

16 LED DM634 და SPI

DM634

ლურჯი აბი STM32F103

შეყვანის გამომავალი

SPI

ქინძისთავების მინიჭება

ჩართეთ დათქმა

STM8 PWM

PWM STM8-ზე

Clocking და I/O

PWM პარამეტრი

STM8 Multiplex

მულტიპლექსირება STM8-ზე

დემუქსი

PWM

წყვეტს

ახალი კომენტარის დამატება

წაიკითხეთ მონაცემთა ცხრილები 2: SPI STM32-ზე; PWM, ტაიმერები და შეფერხებები STM8-ზე

STM32

16 LED DM634 და SPI

DM634

ლურჯი აბი STM32F103

შეყვანის გამომავალი

SPI

ქინძისთავების მინიჭება

ჩართეთ დათქმა

STM8 PWM

PWM STM8-ზე

Clocking და I/O

PWM პარამეტრი

STM8 Multiplex

მულტიპლექსირება STM8-ზე

დემუქსი

PWM

წყვეტს

ახალი კომენტარის დამატება პასუხის გასაუქმებლად

ახალი კომენტარის დამატება