В ផ្នែកដំបូង។ ខ្ញុំបានព្យាយាមប្រាប់វិស្វករអេឡិចត្រូនិចដែលមានចំណង់ចំណូលចិត្តដែលធំឡើងពីខោ Arduino ពីរបៀប និងមូលហេតុដែលពួកគេគួរអាន datasheets និងឯកសារផ្សេងទៀតសម្រាប់ microcontrollers ។ អត្ថបទប្រែជាធំ ដូច្នេះខ្ញុំបានសន្យាថានឹងបង្ហាញឧទាហរណ៍ជាក់ស្តែងនៅក្នុងអត្ថបទដាច់ដោយឡែកមួយ។ អញ្ចឹងគាត់ហៅខ្លួនឯងថាផ្សិតទឹកដោះគោ ...

ថ្ងៃនេះខ្ញុំនឹងបង្ហាញអ្នកពីរបៀបប្រើ datasheets ដើម្បីដោះស្រាយយ៉ាងសាមញ្ញ ប៉ុន្តែចាំបាច់សម្រាប់គម្រោងជាច្រើន ភារកិច្ចនៅលើ STM32 (Blue Pill) និង STM8 controllers។ គម្រោងសាកល្បងទាំងអស់ត្រូវបានឧទ្ទិសដល់ LEDs ដែលខ្ញុំចូលចិត្ត យើងនឹងបំភ្លឺពួកវាក្នុងបរិមាណច្រើន ដែលយើងនឹងត្រូវប្រើគ្រឿងកុំព្យូទ័រដែលគួរឱ្យចាប់អារម្មណ៍គ្រប់ប្រភេទ។

អត្ថបទប្រែជាធំម្តងទៀត ដូច្នេះដើម្បីភាពងាយស្រួល ខ្ញុំកំពុងបង្កើតខ្លឹមសារ៖

STM32 Blue Pill: អំពូល LED ចំនួន 16 ជាមួយកម្មវិធីបញ្ជា DM634
STM8៖ ដំឡើងម្ជុល PWM ចំនួនប្រាំមួយ។
STM8: 8 RGB LEDs នៅលើម្ជុលបី, រំខាន

ការបដិសេធ៖ ខ្ញុំមិនមែនជាវិស្វករទេ ខ្ញុំមិនធ្វើពុតជាមានចំណេះដឹងជ្រៅជ្រះក្នុងផ្នែកអេឡិចត្រូនិចទេ អត្ថបទគឺមានបំណងសម្រាប់អ្នកដែលចូលចិត្តការងារដូចជាខ្ញុំ។ តាមពិតទៅ ខ្ញុំបានចាត់ទុកខ្លួនឯងកាលពីពីរឆ្នាំមុនថាជាទស្សនិកជនគោលដៅ។ ប្រសិនបើនរណាម្នាក់បានប្រាប់ខ្ញុំថា សន្លឹកទិន្នន័យនៅលើបន្ទះឈីបដែលមិនធ្លាប់ស្គាល់មិនគួរឱ្យខ្លាចក្នុងការអានទេ ខ្ញុំមិនចំណាយពេលច្រើនក្នុងការស្វែងរកបំណែកនៃកូដនៅលើអ៊ីនធឺណិត និងបង្កើតឈើច្រត់ដោយប្រើកន្ត្រៃ និងកាសែតស្អិតនោះទេ។

ការផ្តោតអារម្មណ៍នៃអត្ថបទនេះគឺនៅលើសន្លឹកទិន្នន័យ មិនមែនជាគម្រោងទេ ដូច្នេះកូដប្រហែលជាមិនសូវស្អាតទេ ហើយជារឿយៗចង្អៀត។ គម្រោងខ្លួនគេគឺសាមញ្ញណាស់ បើទោះបីជាសាកសមសម្រាប់អ្នកស្គាល់គ្នាដំបូងជាមួយបន្ទះឈីបថ្មីក៏ដោយ។

ខ្ញុំសង្ឃឹមថាអត្ថបទរបស់ខ្ញុំនឹងជួយនរណាម្នាក់នៅដំណាក់កាលស្រដៀងគ្នានៃការជ្រមុជនៅក្នុងចំណង់ចំណូលចិត្ត។

STM32

16 LEDs ជាមួយ DM634 និង SPI

គម្រោងតូចមួយដែលប្រើប្រាស់ Blue Pill (STM32F103C8T6) និង DM634 LED driver។ ដោយប្រើឯកសារទិន្នន័យ យើងនឹងស្វែងរកអ្នកបើកបរ ច្រក STM IO និងកំណត់រចនាសម្ព័ន្ធ SPI ។

DM634

បន្ទះឈីបតៃវ៉ាន់ដែលមានទិន្នផល PWM 16 ប៊ីត អាចត្រូវបានភ្ជាប់ជាច្រវាក់។ ម៉ូដែល 16-bit កម្រិតទាបត្រូវបានគេស្គាល់ពីគម្រោងក្នុងស្រុក កញ្ចប់ពន្លឺ. នៅពេលមួយ ការជ្រើសរើសរវាង DM63x និង TLC5940 ដ៏ល្បី ខ្ញុំបានជ្រើសរើស DM សម្រាប់ហេតុផលជាច្រើន៖ 1) TLC នៅលើ Aliexpress គឺពិតជាក្លែងក្លាយ ប៉ុន្តែមួយនេះមិនមែនទេ។ 2) DM មាន PWM ស្វយ័តជាមួយនឹងម៉ាស៊ីនភ្លើងប្រេកង់ផ្ទាល់របស់វា។ 3) វាអាចត្រូវបានទិញក្នុងតម្លៃថោកនៅទីក្រុងមូស្គូជាជាងរង់ចាំក្បាលដីពីអាលី។ ហើយជាការពិតណាស់ វាគួរឱ្យចាប់អារម្មណ៍ក្នុងការរៀនពីរបៀបគ្រប់គ្រងបន្ទះឈីបដោយខ្លួនឯង ជាជាងការប្រើបណ្ណាល័យដែលត្រៀមរួចជាស្រេច។ ឥឡូវនេះបន្ទះសៀគ្វីត្រូវបានបង្ហាញជាចម្បងនៅក្នុងកញ្ចប់ SSOP24 ពួកវាងាយស្រួលក្នុងការលក់ទៅអាដាប់ទ័រ។

ចាប់តាំងពីក្រុមហ៊ុនផលិតគឺតៃវ៉ាន់។ សន្លឹកទិន្នន័យ បន្ទះឈីបនេះត្រូវបានសរសេរជាភាសាអង់គ្លេសចិន ដែលមានន័យថាវានឹងរីករាយ។ ដំបូងយើងមើល pinout (ការ​តភ្ជាប់​ខ្ទាស់) ដើម្បី​យល់​ថា​ជើង​មួយ​ណា​ត្រូវ​ភ្ជាប់​អ្វី​ទៅ​នឹង​ការ​ពិពណ៌នា​អំពី​ម្ជុល (ពិនពិពណ៌នា) ១៦ ម្ជុល៖

ប្រភព DC Sink (Open Drain)

លិច / ទិន្នផលបើកចំហ - បង្ហូរ; ប្រភពនៃលំហូរចូល; ទិន្នផលត្រូវបានភ្ជាប់ទៅនឹងដីក្នុងស្ថានភាពសកម្ម - អំពូល LED ត្រូវបានភ្ជាប់ទៅអ្នកបើកបរដោយ cathodes ។ តាម​រយៈ​អគ្គិសនី នេះ​គឺ​ជា​ការ​ពិត​ណាស់​មិន​មែន​ជា "ការ​បង្ហូរ​ចេញ" (បើកបង្ហូរ) ប៉ុន្តែនៅក្នុងឯកសារទិន្នន័យ ការកំណត់នេះសម្រាប់ម្ជុលនៅក្នុងរបៀបបង្ហូរត្រូវបានរកឃើញជាញឹកញាប់។

ឧបករណ៍ទប់ទល់ខាងក្រៅរវាង REXT និង GND ដើម្បីកំណត់តម្លៃបច្ចុប្បន្នទិន្នផល

រេស៊ីស្តង់យោងមួយត្រូវបានតំឡើងនៅចន្លោះម្ជុល REXT និងដី ដែលគ្រប់គ្រងភាពធន់ខាងក្នុងនៃទិន្នផល សូមមើលក្រាហ្វនៅទំព័រទី 9 នៃសន្លឹកទិន្នន័យ។ នៅក្នុង DM634 ភាពធន់នេះក៏អាចត្រូវបានគ្រប់គ្រងដោយកម្មវិធីផងដែរ ដោយកំណត់ពន្លឺទាំងមូល (ពន្លឺសកល); ខ្ញុំនឹងមិនចូលទៅក្នុងព័ត៌មានលម្អិតនៅក្នុងអត្ថបទនេះទេ ខ្ញុំនឹងដាក់រេស៊ីស្តង់ 2.2 - 3 kOhm នៅទីនេះ។

ដើម្បីយល់ពីរបៀបគ្រប់គ្រងបន្ទះឈីប សូមមើលការពិពណ៌នានៃចំណុចប្រទាក់ឧបករណ៍៖

បាទ នេះ​គឺ​ជា​ភាសា​អង់គ្លេស​ចិន​ក្នុង​សិរី​ល្អ​ទាំង​អស់​របស់​វា​។ ការបកប្រែនេះគឺមានបញ្ហា អ្នកអាចយល់បានប្រសិនបើអ្នកចង់ ប៉ុន្តែមានវិធីមួយផ្សេងទៀត - មើលពីរបៀបដែលការតភ្ជាប់ទៅ TLC5940 ដែលមានមុខងារស្រដៀងគ្នាត្រូវបានពិពណ៌នានៅក្នុងតារាងទិន្នន័យ៖

... មានតែម្ជុលបីប៉ុណ្ណោះដែលត្រូវបញ្ចូលទិន្នន័យទៅក្នុងឧបករណ៍។ គែមកើនឡើងនៃសញ្ញា SCLK ផ្លាស់ប្តូរទិន្នន័យពី SIN pin ទៅការចុះឈ្មោះខាងក្នុង។ បន្ទាប់ពីទិន្នន័យទាំងអស់ត្រូវបានផ្ទុក សញ្ញា XLAT ខ្ពស់ខ្លីមួយនឹងភ្ជាប់ទិន្នន័យដែលបានផ្ទេរជាបន្តបន្ទាប់ទៅក្នុងបញ្ជីខាងក្នុង។ ការចុះឈ្មោះខាងក្នុងគឺជាច្រកដែលបង្កឡើងដោយកម្រិតសញ្ញា XLAT ។ ទិន្នន័យ​ទាំងអស់​ត្រូវ​បាន​បញ្ជូន​ដំបូង​បំផុត​បន្តិច។

បាច់ - សោ / សោ / សោ។
គែមកើនឡើង - គែមនាំមុខនៃជីពចរ
MSB ដំបូង - សំខាន់បំផុត (ឆ្វេងបំផុត) ទៅមុខ។
ទៅទិន្នន័យនាឡិកា - បញ្ជូនទិន្នន័យតាមលំដាប់លំដោយ (បន្តិចម្ដងៗ)។

ពាក្យ ចាក់សោ ជាញឹកញាប់ត្រូវបានរកឃើញនៅក្នុងឯកសារសម្រាប់បន្ទះសៀគ្វី ហើយត្រូវបានបកប្រែតាមវិធីផ្សេងៗ ដូច្នេះសម្រាប់ជាប្រយោជន៍នៃការយល់ដឹង ខ្ញុំនឹងអនុញ្ញាតឱ្យខ្លួនខ្ញុំ

កម្មវិធីអប់រំតូចមួយកម្មវិធីបញ្ជា LED គឺសំខាន់សម្រាប់ការចុះឈ្មោះផ្លាស់ប្តូរ។ "ប្តូរ" (shift) នៅក្នុងឈ្មោះ - ចលនាប៊ីតនៃទិន្នន័យនៅខាងក្នុងឧបករណ៍៖ ប៊ីតថ្មីនីមួយៗដែលរុញនៅខាងក្នុងរុញច្រវ៉ាក់ទាំងមូលទៅមុខនៅពីមុខវា។ ដោយសារគ្មាននរណាម្នាក់ចង់សង្កេតមើលការភ្លឹបភ្លែតៗនៃ LEDs កំឡុងពេលផ្លាស់ប្តូរដំណើរការនេះកើតឡើងនៅក្នុងការចុះបញ្ជីសតិបណ្ដោះអាសន្នដែលបំបែកចេញពីបញ្ជីការងារដោយ damper (ចាក់សោ) គឺជាប្រភេទបន្ទប់រង់ចាំដែលប៊ីតត្រូវបានរៀបចំតាមលំដាប់ដែលចង់បាន។ នៅពេលដែលអ្វីៗគ្រប់យ៉ាងរួចរាល់ សន្ទះបិទបើក ហើយប៊ីតនឹងដំណើរការ ដោយជំនួសបាច់មុន។ ពាក្យ ចាក់សោ នៅក្នុងឯកសារសម្រាប់ microcircuits ស្ទើរតែតែងតែបង្កប់ន័យដូចជា damper មិនថានៅក្នុងបន្សំអ្វីដែលវាត្រូវបានប្រើ។

ដូច្នេះការផ្ទេរទិន្នន័យទៅ DM634 ត្រូវបានអនុវត្តដូចនេះ: កំណត់ការបញ្ចូល DAI ទៅនឹងតម្លៃនៃប៊ីតដ៏សំខាន់បំផុតនៃ LED ឆ្ងាយ ទាញ DCK ឡើងលើចុះក្រោម។ កំណត់ការបញ្ចូល DAI ទៅតម្លៃនៃប៊ីតបន្ទាប់ ទាញ DCK; ហើយបន្តរហូតដល់ប៊ីតទាំងអស់ត្រូវបានបញ្ជូន (នាឡិកាចូល) បន្ទាប់ពីនោះយើងទាញ LAT ។ នេះអាចត្រូវបានធ្វើដោយដៃ (ប៊ីត) ប៉ុន្តែវាជាការប្រសើរក្នុងការប្រើចំណុចប្រទាក់ SPI ដែលត្រូវបានរចនាឡើងជាពិសេសសម្រាប់ការនេះ ព្រោះវាត្រូវបានបង្ហាញនៅលើ STM32 របស់យើងជាពីរច្បាប់ចម្លង។

ថ្នាំគ្រាប់ពណ៌ខៀវ STM32F103

ការណែនាំ៖ ឧបករណ៍បញ្ជា STM32 មានភាពស្មុគ្រស្មាញជាង Atmega328 ជាងវាហាក់ដូចជាគួរឱ្យខ្លាច។ លើសពីនេះទៅទៀត សម្រាប់ហេតុផលនៃការសន្សំថាមពល គ្រឿងកុំព្យូទ័រស្ទើរតែទាំងអស់ត្រូវបានបិទនៅពេលចាប់ផ្តើម ហើយប្រេកង់នាឡិកាគឺ 8 MHz ពីប្រភពខាងក្នុង។ ជាសំណាងល្អ អ្នកសរសេរកម្មវិធី STM បានសរសេរកូដដែលនាំបន្ទះឈីបឡើងដល់ "គណនា" 72 MHz ហើយអ្នកនិពន្ធនៃ IDE ទាំងអស់ដែលខ្ញុំស្គាល់បានបញ្ចូលវាទៅក្នុងដំណើរការចាប់ផ្តើម ដូច្នេះយើងមិនចាំបាច់នាឡិកាទេ (ប៉ុន្តែ អ្នកអាចប្រសិនបើអ្នកពិតជាចង់) ប៉ុន្តែអ្នកនឹងត្រូវបើកគ្រឿងកុំព្យូទ័រ។

ឯកសារ៖ Blue Pill ត្រូវបានបំពាក់ដោយបន្ទះឈីបដ៏ពេញនិយម STM32F103C8T6 មានឯកសារមានប្រយោជន៍ពីរសម្រាប់វា៖

• សន្លឹកទិន្នន័យ សម្រាប់ microcontrollers STM32F103x8 និង STM32F103xB;
• សៀវភៅដៃយោង សម្រាប់ខ្សែ STM32F103 ទាំងមូល និងច្រើនទៀត។

នៅក្នុងតារាងទិន្នន័យ យើងអាចចាប់អារម្មណ៍៖

• Pinouts - chip pinouts - ក្នុងករណីដែលយើងសម្រេចចិត្តធ្វើក្តារដោយខ្លួនឯង;
• Memory Map - ផែនទីសតិសម្រាប់បន្ទះឈីបជាក់លាក់មួយ។ សៀវភៅណែនាំឯកសារយោងមានផែនទីសម្រាប់បន្ទាត់ទាំងមូល ហើយវានិយាយអំពីការចុះឈ្មោះដែលយើងមិនមាន។
• តារាងនិយមន័យ Pin - រាយមុខងារសំខាន់ និងជំនួសនៃម្ជុល; សម្រាប់ "ថ្នាំគ្រាប់ពណ៌ខៀវ" អ្នកអាចស្វែងរករូបភាពកាន់តែងាយស្រួលនៅលើអ៊ីនធឺណិត ជាមួយនឹងបញ្ជីម្ជុល និងមុខងាររបស់វា។ ដូច្នេះហើយ យើងភ្លាមៗ google Blue Pill pinout ហើយរក្សារូបភាពនេះនៅនឹងដៃ៖

NB: មានកំហុសនៅក្នុងរូបភាពពីអ៊ីនធឺណិត ដែលត្រូវបានកត់សម្គាល់នៅក្នុងមតិយោបល់ សូមអរគុណចំពោះវា។ រូបភាពត្រូវបានជំនួសប៉ុន្តែនេះគឺជាមេរៀនមួយ - វាជាការប្រសើរក្នុងការត្រួតពិនិត្យព័ត៌មានមិនមែនពីសន្លឹកទិន្នន័យទេ។

យើងដកសន្លឹកទិន្នន័យចេញ បើកសៀវភៅណែនាំឯកសារយោង ហើយចាប់ពីពេលនេះតទៅ យើងប្រើតែវាប៉ុណ្ណោះ។
នីតិវិធី៖ យើងដោះស្រាយជាមួយនឹងការបញ្ចូល/ទិន្នផលស្តង់ដារ កំណត់រចនាសម្ព័ន្ធ SPI បើកឧបករណ៍ចាំបាច់។

បញ្ចូលទិន្នផល

នៅលើ Atmega328 I/O ត្រូវបានអនុវត្តយ៉ាងសាមញ្ញ ដែលនេះជាមូលហេតុដែលភាពសម្បូរបែបនៃជម្រើស STM32 អាចមានការភ័ន្តច្រឡំ។ ឥឡូវនេះយើងគ្រាន់តែត្រូវការការសន្និដ្ឋានប៉ុណ្ណោះ ប៉ុន្តែសូម្បីតែជម្រើសទាំងនេះក៏មានជម្រើសបួនដែរ៖

បង្ហូរបើកចំហ, រុញទាញ, រុញច្រានជំនួស, បង្ហូរបើកចំហជំនួស

"ទាញ-រុញ" (ជំរុញ - ទាញ) គឺជាទិន្នផលធម្មតាពី Arduino ម្ជុលអាចយកតម្លៃបានទាំង HIGH ឬ LOW ។ ប៉ុន្តែជាមួយនឹង "បង្ហូរបើកចំហ" មាន ការលំបាកទោះបីជាការពិតអ្វីគ្រប់យ៉ាងគឺសាមញ្ញនៅទីនេះ៖

ការកំណត់រចនាសម្ព័ន្ធទិន្នផល / នៅពេលដែលច្រកត្រូវបានផ្តល់ទៅទិន្នផល: / សតិបណ្ដោះអាសន្នទិន្នផលបានបើក: / – បើករបៀបបង្ហូរ: "0" នៅក្នុងបញ្ជីទិន្នផលបើក N-MOS, "1" នៅក្នុងបញ្ជីទិន្នផលទុកច្រកក្នុងរបៀប Hi-Z ( P-MOS មិន​ត្រូវ​បាន​ធ្វើ​ឱ្យ​សកម្ម​) / – របៀប​រុញ​ទាញ​: "0​" នៅ​ក្នុង​ការ​ចុះ​ឈ្មោះ​លទ្ធផល​ធ្វើ​ឱ្យ​សកម្ម N-MOS, "1​" នៅ​ក្នុង​បញ្ជី​ទិន្នផល​ធ្វើ​ឱ្យ P-MOS សកម្ម​។

ភាពខុសគ្នាទាំងអស់រវាងការបង្ហូរបើកចំហ (បើកបង្ហូរ) ពី "រុញ - ទាញ" (ជំរុញ - ទាញ) គឺថានៅក្នុងម្ជុលទីមួយមិនអាចទទួលយកស្ថានភាព HIGH បានទេ៖ នៅពេលសរសេរមួយទៅបញ្ជីទិន្នផល វាចូលទៅក្នុងរបៀបធន់ទ្រាំខ្ពស់ (impedance ខ្ពស់។, ហ៊ីហ្សេ) នៅពេលសរសេរលេខសូន្យ ម្ជុលមានដំណើរការដូចគ្នាក្នុងរបៀបទាំងពីរ ទាំងឡូជីខល និងអេឡិចត្រូនិច។

នៅក្នុងរបៀបទិន្នផលធម្មតា ម្ជុលគ្រាន់តែផ្សាយមាតិកានៃបញ្ជីលទ្ធផល។ នៅក្នុង "ជម្រើស" វាត្រូវបានគ្រប់គ្រងដោយគ្រឿងកុំព្យូទ័រដែលត្រូវគ្នា (សូមមើល 9.1.4):

ប្រសិនបើ​ច្រក​ប៊ីត​ត្រូវ​បាន​កំណត់​រចនាសម្ព័ន្ធ​ជា​ម្ជុល​មុខងារ​ជំនួស នោះ​ការ​ចុះឈ្មោះ​ម្ជុល​ត្រូវ​បាន​បិទ ហើយ​ម្ជុល​ត្រូវ​បាន​តភ្ជាប់​ទៅ​ម្ជុល​គ្រឿងកុំព្យូទ័រ។

មុខងារជំនួសនៃម្ជុលនីមួយៗត្រូវបានពិពណ៌នានៅក្នុង ពិននិយមន័យ សន្លឹកទិន្នន័យគឺនៅលើរូបភាពដែលបានទាញយក។ ចំពោះសំណួរនៃអ្វីដែលត្រូវធ្វើប្រសិនបើម្ជុលមានមុខងារជំនួសជាច្រើន ចម្លើយត្រូវបានផ្តល់ដោយលេខយោងនៅក្នុងតារាងទិន្នន័យ៖

ប្រសិនបើគ្រឿងកុំព្យូទ័រច្រើនប្រើម្ជុលដូចគ្នា ដើម្បីជៀសវាងការប៉ះទង្គិចរវាងមុខងារជំនួស មានតែគ្រឿងកុំព្យូទ័រមួយប៉ុណ្ណោះគួរតែត្រូវបានប្រើក្នុងពេលតែមួយ ដោយបិទបើកដោយប្រើនាឡិកាគ្រឿងកុំព្យូទ័របើកប៊ីត (នៅក្នុងការចុះឈ្មោះ RCC ដែលសមស្រប)។

ចុងក្រោយ ម្ជុលនៅក្នុងរបៀបទិន្នផលក៏មានល្បឿននាឡិកាផងដែរ។ នេះគឺជាមុខងារសន្សំសំចៃថាមពលមួយផ្សេងទៀត ក្នុងករណីរបស់យើង យើងគ្រាន់តែកំណត់វាដល់អតិបរមា ហើយបំភ្លេចវាចោល។

ដូច្នេះ៖ យើងកំពុងប្រើ SPI ដែលមានន័យថាម្ជុលពីរ (ជាមួយទិន្នន័យ និងសញ្ញានាឡិកា) គួរតែជា "មុខងាររុញច្រានជំនួស" ហើយមួយទៀត (LAT) គួរតែជា "ការរុញច្រានទៀងទាត់" ។ ប៉ុន្តែ​មុន​នឹង​ចាត់តាំង​ពួកគេ សូម​ដោះស្រាយ​ជាមួយ SPI ។

SPI

កម្មវិធីអប់រំតូចមួយទៀត។

SPI ឬ Serial Peripheral Interface (serial peripheral interface) គឺជាចំណុចប្រទាក់សាមញ្ញ និងមានប្រសិទ្ធភាពបំផុតសម្រាប់ភ្ជាប់ MK ជាមួយ MKs ផ្សេងទៀត និងពិភពខាងក្រៅជាទូទៅ។ គោលការណ៍នៃប្រតិបត្តិការរបស់វាត្រូវបានពិពណ៌នាខាងលើរួចហើយដែលអំពីកម្មវិធីបញ្ជា LED របស់ចិន (នៅក្នុងសៀវភៅណែនាំយោងសូមមើលផ្នែកទី 25) ។ SPI អាចដំណើរការនៅក្នុងរបៀបមេ ("មេ") និងទាសករ ("ទាសករ") ។ SPI មានបណ្តាញមូលដ្ឋានចំនួន XNUMX ដែលមិនមែនទាំងអស់អាចប្រើបានទេ៖

• MOSI, Master Output / Slave Input: ម្ជុលនេះបញ្ជូនទិន្នន័យក្នុងទម្រង់មេ និងទទួលទិន្នន័យក្នុងរបៀប slave ។
• MISO, Master Input / Slave Output: ផ្ទុយទៅវិញ វាទទួលបាននៅក្នុងមេ និងបញ្ជូននៅក្នុងទាសករ។
• SCK, Serial Clock៖ កំណត់ប្រេកង់នៃការបញ្ជូនទិន្នន័យនៅក្នុងមេ ឬទទួលសញ្ញានាឡិកានៅក្នុង slave ។ ការវាយដំសំខាន់;
• SS, Slave Select៖ ដោយមានជំនួយពីឆានែលនេះ ទាសករដឹងថាអ្វីមួយត្រូវបានគេចង់បានពីគាត់។ នៅលើ STM32 វាត្រូវបានគេហៅថា NSS ដែល N = negative, i.e. ឧបករណ៍បញ្ជាក្លាយជាទាសករប្រសិនបើមានដីនៅក្នុងឆានែលនេះ។ វារួមបញ្ចូលគ្នាយ៉ាងល្អជាមួយរបៀបបើកបង្ហូរចេញ ប៉ុន្តែនោះជារឿងមួយទៀត។

ដូចអ្វីផ្សេងទៀតដែរ SPI នៅលើ STM32 សម្បូរទៅដោយមុខងារ ដែលធ្វើឱ្យវាពិបាកយល់ខ្លះៗ។ ជាឧទាហរណ៍ វាអាចដំណើរការមិនត្រឹមតែជាមួយ SPI ប៉ុណ្ណោះទេ ប៉ុន្តែក៏មានចំណុចប្រទាក់ I2S ផងដែរ ហើយនៅក្នុងឯកសារ ការពិពណ៌នារបស់ពួកគេត្រូវបានលាយបញ្ចូលគ្នា វាចាំបាច់ក្នុងការកាត់ផ្តាច់លើសក្នុងលក្ខណៈទាន់ពេលវេលា។ ភារកិច្ចរបស់យើងគឺសាមញ្ញបំផុត៖ យើងគ្រាន់តែត្រូវការផ្ញើទិន្នន័យដោយប្រើតែ MOSI និង SCK ប៉ុណ្ណោះ។ យើងទៅផ្នែក 25.3.4 (ការទំនាក់ទំនងពាក់កណ្តាលពីរ ការទំនាក់ទំនងពាក់កណ្តាលពីរ) ដែលយើងរកឃើញ នាឡិកា 1 និងខ្សែទិន្នន័យ 1 ឯកទិស (1 សញ្ញានាឡិកា និង 1 លំហូរទិន្នន័យ unidirectional):

នៅក្នុងរបៀបនេះ កម្មវិធីប្រើប្រាស់ SPI នៅក្នុងរបៀបបញ្ជូនបានតែ ឬទទួលតែប៉ុណ្ណោះ។ / របៀបបញ្ជូនតែប៉ុណ្ណោះគឺស្រដៀងទៅនឹងរបៀបពីរ៖ ទិន្នន័យត្រូវបានបញ្ជូននៅលើម្ជុលបញ្ជូន (MOSI នៅក្នុងរបៀបមេ ឬ MISO នៅក្នុងរបៀបទាសករ) ហើយម្ជុលទទួល (MISO ឬ MOSI រៀងគ្នា) អាចត្រូវបានប្រើជាម្ជុល I/O ធម្មតា . ក្នុងករណីនេះកម្មវិធីគ្រាន់តែត្រូវការមិនអើពើនឹងសតិបណ្ដោះអាសន្ន Rx (ប្រសិនបើវាត្រូវបានអានវានឹងមិនមានទិន្នន័យផ្ទេរនៅទីនោះទេ) ។

ល្អណាស់ ម្ជុល MISO មិនគិតថ្លៃទេ សូមភ្ជាប់សញ្ញា LAT ទៅវា។ សូមក្រឡេកមើល Slave Select ដែលនៅលើ STM32 អាចត្រូវបានគ្រប់គ្រងតាមកម្មវិធី ដែលជាភាពងាយស្រួលបំផុត។ យើងអានកថាខណ្ឌនៃឈ្មោះដូចគ្នានៅក្នុងផ្នែក 25.3.1 SPI ការពិពណ៌នាទូទៅ៖

ការគ្រប់គ្រងកម្មវិធី NSS (SSM = 1) / ព័ត៌មានការជ្រើសរើសទាសករមាននៅក្នុង SSI ប៊ីតនៃការចុះឈ្មោះ SPI_CR1 ។ ម្ជុល 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 ការពិពណ៌នាទូទៅ)៖

ដំណាក់កាលនាឡិកា និងរាងប៉ូល។
ដោយប្រើប៊ីត CPOL និង CPHA នៃការចុះឈ្មោះ SPI_CR1 អ្នកអាចជ្រើសរើសទំនាក់ទំនងពេលវេលាចំនួនបួនតាមកម្មវិធី។ ប៊ីត CPOL (រាងប៉ូលនៃនាឡិកា) គ្រប់គ្រងស្ថានភាពនៃសញ្ញានាឡិកា នៅពេលដែលគ្មានទិន្នន័យត្រូវបានបញ្ជូន។ ប៊ីតនេះគ្រប់គ្រងរបៀបមេ និងទាសករ។ ប្រសិនបើ CPOL ត្រូវបានកំណត់ឡើងវិញ ម្ជុល SCK មានកម្រិតទាបនៅក្នុងរបៀបសម្រាក។ ប្រសិនបើប៊ីត CPOL ត្រូវបានកំណត់ ម្ជុល SCK ខ្ពស់អំឡុងពេលសម្រាក។
នៅពេលដែល CPHA (ដំណាក់កាលនាឡិកា) ប៊ីតត្រូវបានកំណត់ ស្ទ្រីបអន្ទាក់ប៊ីតខ្ពស់គឺជាគែមទីពីរនៃសញ្ញា SCK (ធ្លាក់ចុះប្រសិនបើ CPOL ច្បាស់លាស់ កើនឡើងប្រសិនបើ CPOL ត្រូវបានកំណត់) ។ ទិន្នន័យត្រូវបានចាប់យកដោយការផ្លាស់ប្តូរទីពីរនៅក្នុងសញ្ញានាឡិកា។ ប្រសិនបើប៊ីត CPHA មានភាពច្បាស់លាស់នោះ ស្ទ្រីបអន្ទាក់ខ្ពស់គឺជាគែមកើនឡើងនៃសញ្ញា SCK (គែមធ្លាក់ចុះប្រសិនបើ CPOL ត្រូវបានកំណត់ គែមកើនឡើងប្រសិនបើ CPOL ត្រូវបានជម្រះ) ។ ទិន្នន័យត្រូវបានចាប់យកនៅការផ្លាស់ប្តូរដំបូងនៅក្នុងសញ្ញានាឡិកា។

ដោយបានស្រូបយកចំណេះដឹងនេះ យើងឈានដល់ការសន្និដ្ឋានថា ប៊ីតទាំងពីរត្រូវតែនៅតែសូន្យ ពីព្រោះ យើងចង់ឱ្យសញ្ញា SCK នៅទាបនៅពេលមិនប្រើ ហើយទិន្នន័យត្រូវបានបញ្ជូននៅលើគែមកើនឡើងនៃជីពចរ (សូមមើលរូបភព។ គែមកើនឡើង សំណុំទិន្នន័យ DM634)

និយាយអីញ្ចឹង នៅទីនេះដំបូងយើងបានជួបប្រទះលក្ខណៈពិសេសមួយនៃវាក្យសព្ទនៅក្នុង ST datasheets: នៅក្នុងពួកគេឃ្លា "កំណត់ឡើងវិញប៊ីតទៅសូន្យ" ត្រូវបានសរសេរ។ ដើម្បីកំណត់ឡើងវិញបន្តិចនិងមិន ដើម្បីជម្រះបន្តិចឧទាហរណ៍ដូចជា Atmega ។

3. កំណត់ DFF bit ដើម្បីកំណត់ថាតើប្លុកទិន្នន័យជាទម្រង់ 8-bit ឬ 16-bit

ជាពិសេសខ្ញុំបានយក 16-bit DM634 ដើម្បីកុំឱ្យរំខានដល់ការបញ្ជូនទិន្នន័យ PWM 12-bit ដូចជា 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 ។
បៃទិន្នន័យត្រូវបានផ្ទុកទៅក្នុងការផ្លាស់ប្តូរចុះឈ្មោះនៅ ប៉ារ៉ាឡែល របៀប (ពីឡានក្រុងខាងក្នុង) កំឡុងពេលបញ្ជូនប៊ីតដំបូង បន្ទាប់មកវាត្រូវបានបញ្ជូនទៅ បន្តបន្ទាប់គ្នា។ MOSI pin mode ទៅមុខបន្តិច ឬចុងក្រោយ អាស្រ័យលើការកំណត់ LSBFIRST bit នៅក្នុងការចុះឈ្មោះ CPI_CR1។ ទង់ TXE ត្រូវបានកំណត់បន្ទាប់ពីការបញ្ជូនទិន្នន័យ ពី Tx buffer ទៅ shift registerហើយក៏បង្កើតការរំខានផងដែរ ប្រសិនបើប៊ីត TXEIE នៅក្នុងការចុះឈ្មោះ CPI_CR1 ត្រូវបានកំណត់។

ខ្ញុំបានគូសបញ្ជាក់ពាក្យមួយចំនួននៅក្នុងការបកប្រែ ដើម្បីទាក់ទាញការយកចិត្តទុកដាក់ចំពោះលក្ខណៈពិសេសមួយនៃការអនុវត្ត SPI នៅក្នុងឧបករណ៍បញ្ជា STM ។ នៅលើ Atmega ទង់ TXE (Tx ទទេ, tx គឺទទេ និងរួចរាល់ក្នុងការទទួលទិន្នន័យ) ត្រូវបានកំណត់តែបន្ទាប់ពីបៃទាំងមូលត្រូវបានផ្ញើ ខាងក្រៅ. ហើយនៅទីនេះទង់នេះត្រូវបានកំណត់បន្ទាប់ពីបៃត្រូវបានបញ្ចូលទៅក្នុងបញ្ជីការផ្លាស់ប្តូរខាងក្នុង។ ដោយសារវាត្រូវបានរុញនៅទីនោះជាមួយប៊ីតទាំងអស់ក្នុងពេលតែមួយ (ស្របគ្នា) ហើយបន្ទាប់មកទិន្នន័យត្រូវបានផ្ទេរជាបន្តបន្ទាប់ TXE ត្រូវបានកំណត់មុនពេលបៃត្រូវបានផ្ញើទាំងស្រុង។ នេះ​ជា​ការ​សំខាន់​ដោយ​សារ​តែ​ នៅក្នុងករណីនៃកម្មវិធីបញ្ជា LED របស់យើងយើងត្រូវទាញម្ជុល LAT បន្ទាប់ពីផ្ញើ всех ទិន្នន័យ, ឧ។ ទង់ TXE តែឯងនឹងមិនគ្រប់គ្រាន់សម្រាប់យើងទេ។

នេះមានន័យថាយើងត្រូវការទង់ជាតិមួយទៀត។ តោះមើល 25.3.7 - "ទង់ស្ថានភាព"៖

<…>

ទង់ BUSY
ទង់ BSY ត្រូវបានកំណត់ និងជម្រះដោយផ្នែករឹង (ការសរសេរទៅវាមិនមានប្រសិទ្ធិភាពទេ) ។ ទង់ BSY បង្ហាញពីស្ថានភាពនៃស្រទាប់ទំនាក់ទំនង SPI ។
វាកំណត់ឡើងវិញ៖
នៅពេលការផ្ទេរត្រូវបានបញ្ចប់ (លើកលែងតែនៅក្នុងរបៀបមេ ប្រសិនបើការផ្ទេរបន្ត)
នៅពេលដែល SPI ត្រូវបានបិទ
នៅពេល​មាន​កំហុស​របៀប​មេ​កើតឡើង (MODF=1)
ប្រសិនបើការផ្ទេរមិនបន្ត ទង់ BSY ត្រូវបានជម្រះរវាងការផ្ទេរទិន្នន័យនីមួយៗ

មិនអីទេ វានឹងមានប្រយោជន៍។ ចូរយើងស្វែងយល់ថាតើកន្លែងផ្ទុក Tx ស្ថិតនៅត្រង់ណា។ ដើម្បីធ្វើដូចនេះសូមអាន "ការចុះឈ្មោះទិន្នន័យ SPI"៖

Bits 15:0 DR [15:0] ការចុះឈ្មោះទិន្នន័យ
ទិន្នន័យដែលទទួលបាន ឬទិន្នន័យដែលត្រូវបញ្ជូន។
ការចុះឈ្មោះទិន្នន័យត្រូវបានបែងចែកជា buffers ពីរ - មួយសម្រាប់ការសរសេរ (បញ្ជូនសតិបណ្ដោះអាសន្ន) និងមួយទៀតសម្រាប់ការអាន (ទទួលបានសតិបណ្ដោះអាសន្ន)។ ការសរសេរទៅបញ្ជីទិន្នន័យ សរសេរទៅសតិបណ្ដោះអាសន្ន 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 ដង XNUMX បៃនេះបើយោងតាមចំនួននៃលទ្ធផលកម្មវិធីបញ្ជា 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) និង 32- ការចុះឈ្មោះទប់ស្កាត់ប៊ីត (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) និងល្បឿន pin (យើងត្រូវការ 50MHz ពោលគឺឧ។ ទាំង pin ទៅ “1”) ហើយ CNF កំណត់របៀប៖ “push-pull” ធម្មតា – 00, “alternative” – 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 ដែលយើងសូមអរគុណពួកគេយ៉ាងខ្លាំង (ជាថ្មីម្តងទៀតខ្ញុំនឹងផ្តល់តំណភ្ជាប់ទៅ គេហទំព័ររបស់ Di Haltដើម្បីធ្វើឱ្យវាច្បាស់ថាតើវាច្រឡំប៉ុណ្ណា) ។ យើងត្រូវការតែការចុះឈ្មោះដែលទទួលខុសត្រូវសម្រាប់ការបើកដំណើរការនាឡិកាជុំវិញ (នាឡិកាគ្រឿងកុំព្យូទ័របើកការចុះឈ្មោះ)។ ជាដំបូង ចូរយើងស្វែងរកអាសយដ្ឋានមូលដ្ឋានរបស់ RCC វាគឺនៅដើមដំបូងនៃ "Memory Map"៖

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

ហើយ​បន្ទាប់​មក​ចុច​លើ​តំណ​ដែល​អ្នក​ព្យាយាម​រក​អ្វី​មួយ​នៅ​ក្នុង​ចាន ឬ​ល្អ​ជាង​នេះ​ទៅ​តាម​ការ​ពិពណ៌នា​នៃ​ការ​ចុះឈ្មោះ​ដែល​អនុញ្ញាត​ពី​ផ្នែក​អំពី បើកការចុះឈ្មោះ. កន្លែងដែលយើងនឹងរកឃើញ RCC_APB1ENR និង RCC_APB2ENR៖

ហើយតាមនោះ ពួកវាមានប៊ីតដែលរួមបញ្ចូលការកំណត់ម៉ោងរបស់ SPI2, IOPB (I/O Port 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.

នាឡិកា និង I/O

តាមលំនាំដើម STM8 ដំណើរការនៅប្រេកង់ 2 ​​MHz វាត្រូវតែកែតម្រូវភ្លាមៗ។

HSI (High Speed ​​​​Internal) នាឡិកា
សញ្ញានាឡិកា HSI ត្រូវបានចេញមកពី 16 MHz RC oscillator ខាងក្នុង ជាមួយនឹងការបែងចែកដែលអាចសរសេរកម្មវិធីបាន (1 ដល់ 8) ។ វាត្រូវបានកំណត់នៅក្នុងបញ្ជីបែងចែកនាឡិកា (CLK_CKDIVR) ។
ចំណាំ៖ នៅពេលចាប់ផ្តើម លំយោល HSI RC ដែលមានការបែងចែក 8 ត្រូវបានជ្រើសរើសជាប្រភពនាំមុខនៃសញ្ញានាឡិកា។

យើងរកឃើញអាសយដ្ឋានចុះឈ្មោះនៅក្នុងតារាងទិន្នន័យ ការពិពណ៌នានៅក្នុង refman ហើយឃើញថាការចុះឈ្មោះចាំបាច់ត្រូវសម្អាត៖

#define CLK_CKDIVR *(volatile uint8_t *)0x0050C6

CLK_CKDIVR &= ~(0x18);

ដោយសារយើងនឹងដំណើរការ PWM និងភ្ជាប់ LEDs សូមក្រឡេកមើល pinout៖

បន្ទះឈីបមានទំហំតូច មុខងារជាច្រើនត្រូវបានផ្អាកនៅលើម្ជុលតែមួយ។ អ្វីដែលនៅក្នុងតង្កៀបការ៉េគឺ "មុខងារជំនួស" វាត្រូវបានប្តូរដោយ "បៃជម្រើស" (ជម្រើសបៃ) - អ្វីមួយដូចជា Atmega fuses ។ អ្នកអាចផ្លាស់ប្តូរតម្លៃរបស់ពួកគេតាមកម្មវិធីប៉ុន្តែវាមិនចាំបាច់ទេព្រោះ មុខងារថ្មីត្រូវបានធ្វើឱ្យសកម្មតែបន្ទាប់ពីការចាប់ផ្ដើមឡើងវិញ។ វាកាន់តែងាយស្រួលប្រើ ST Visual Programmer (ទាញយកជាមួយ Visual Develop) ដែលអាចផ្លាស់ប្តូរបៃទាំងនេះ។ pinout បង្ហាញថាម្ជុល CH1 និង CH2 របស់ឧបករណ៍កំណត់ម៉ោងដំបូងត្រូវបានលាក់នៅក្នុងតង្កៀបការ៉េ។ វាចាំបាច់ក្នុងការកំណត់ AFR1 និង AFR0 ប៊ីតនៅក្នុង STVP ហើយទីពីរក៏នឹងផ្ទេរលទ្ធផល CH1 នៃកម្មវិធីកំណត់ម៉ោងទីពីរពី PD4 ទៅ PC5 ផងដែរ។

ដូច្នេះ 6 pins នឹងគ្រប់គ្រង LEDs: PC6, PC7 និង PC3 សម្រាប់កម្មវិធីកំណត់ម៉ោងដំបូង PC5, PD3 និង PA3 សម្រាប់លើកទីពីរ។

ការដំឡើង I/O pins ដោយខ្លួនឯងនៅលើ STM8 គឺសាមញ្ញ និងឡូជីខលជាងនៅលើ STM32៖

• ស្គាល់ពីការចុះឈ្មោះទិសដៅទិន្នន័យ Atmega DDR (ការចុះឈ្មោះទិសដៅទិន្នន័យ): 1 = ទិន្នផល;
• ការចុះឈ្មោះវត្ថុបញ្ជាដំបូង CR1 នៅពេលដែលទិន្នផលកំណត់របៀបរុញទាញ (1) ឬបើកបង្ហូរ (0); ដោយសារខ្ញុំភ្ជាប់ LEDs ទៅបន្ទះឈីបជាមួយ cathodes ខ្ញុំទុកសូន្យនៅទីនេះ។
• ការត្រួតពិនិត្យទីពីរចុះឈ្មោះ 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 នឹងខូច។ ដូច្នេះតម្លៃបញ្ជូនថ្មីត្រូវបានដាក់ក្នុងសតិបណ្ដោះអាសន្ន ហើយទាញចេញនៅពេលដែលកម្មវិធីកំណត់ម៉ោងឈានដល់ចុងបញ្ចប់នៃការរាប់ថយក្រោយរបស់វា ហើយត្រូវបានកំណត់ឡើងវិញ។
• តម្រឹមគែម и របៀបតម្រឹមកណ្តាល - ការតម្រឹមតាមព្រំដែន និងនៅកណ្តាល ដូចគ្នានឹង Atmel's PWM លឿន и PWM ដំណាក់កាលត្រឹមត្រូវ។.
• OciREF, ទិន្នផលប្រៀបធៀបសញ្ញាយោង - សញ្ញាទិន្នផលយោង តាមពិតអ្វីដែលបង្ហាញនៅលើម្ជុលដែលត្រូវគ្នានៅក្នុងរបៀប PWM ។

ដូចដែលបានបញ្ជាក់រួចមកហើយពី pinout ឧបករណ៍កំណត់ពេលវេលាពីរមានសមត្ថភាព PWM - ទីមួយនិងទីពីរ។ ទាំងពីរគឺ 16-bit ដែលទីមួយមានមុខងារបន្ថែមជាច្រើន (ជាពិសេសវាអាចរាប់បានទាំងឡើងលើ និងចុះក្រោម)។ យើងត្រូវការទាំងពីរដើម្បីធ្វើការស្មើៗគ្នា ដូច្នេះខ្ញុំបានសម្រេចចិត្តចាប់ផ្តើមជាមួយនឹងទីពីរដែលកាន់តែអន់ជាងនេះ ដើម្បីកុំឱ្យប្រើរបស់ដែលមិនមានដោយចៃដន្យ។ បញ្ហាខ្លះគឺថាការពិពណ៌នាអំពីមុខងារ PWM នៃកម្មវិធីកំណត់ម៉ោងទាំងអស់នៅក្នុងសៀវភៅណែនាំគឺនៅក្នុងជំពូកអំពីកម្មវិធីកំណត់ម៉ោងដំបូង (17.5.7 PWM Mode) ដូច្នេះអ្នកត្រូវលោតទៅក្រោយពេញឯកសារគ្រប់ពេល។

PWM នៅលើ STM8 មានអត្ថប្រយោជន៍សំខាន់ជាង PWM នៅលើ Atmega:

តម្រឹមព្រំដែន PWM
ការកំណត់រចនាសម្ព័ន្ធគណនីពីបាតឡើងលើ
ការរាប់ពីបាតឡើងលើគឺសកម្ម ប្រសិនបើប៊ីត DIR នៅក្នុងការចុះឈ្មោះ TIM_CR1 ត្រូវបានសម្អាត
ឧទាហរណ៍:
ឧទាហរណ៍ប្រើរបៀប PWM ដំបូង។ សញ្ញាយោង PWM OCiREF ត្រូវបានរក្សាខ្ពស់ដរាបណា TIM1_CNT < TIM1_CCRi ។ បើមិនដូច្នោះទេវាត្រូវការកម្រិតទាប។ ប្រសិនបើតម្លៃប្រៀបធៀបនៅក្នុងការចុះឈ្មោះ TIM1_CCRi ធំជាងតម្លៃ autoload (ការចុះឈ្មោះ TIM1_ARR) នោះសញ្ញា OCiREF នឹងស្ថិតនៅលេខ 1។ ប្រសិនបើតម្លៃប្រៀបធៀបគឺ 0 នោះ OCiREF ត្រូវបានរក្សានៅសូន្យ។...

កម្មវិធីកំណត់ម៉ោង STM8 អំឡុងពេល ធ្វើបច្ចុប្បន្នភាពព្រឹត្តិការណ៍ ពិនិត្យជាមុនសិន ប្រៀបធៀបតម្លៃហើយមានតែបន្ទាប់មកបង្កើតសញ្ញាយោង។ កម្មវិធីកំណត់ម៉ោងរបស់ Atmega ចាប់ផ្តើមដំបូង ហើយបន្ទាប់មកប្រៀបធៀប លទ្ធផល compare value == 0 លទ្ធផលគឺជាម្ជុល ដែលត្រូវតែដោះស្រាយដោយវិធីណាមួយ (ឧទាហរណ៍ ដោយដាក់បញ្ច្រាសតក្កវិជ្ជាតាមកម្មវិធី)។

ដូច្នេះអ្វីដែលយើងចង់ធ្វើ៖ 8-bit PWM (AR == 255) រាប់ពីបាតដល់កំពូល តម្រឹមតាមព្រំដែន។ ដោយសារអំពូលភ្លើងត្រូវបានភ្ជាប់ទៅបន្ទះឈីបដោយ cathodes PWM គួរតែបញ្ចេញ 0 (LED on) រហូតដល់ ប្រៀបធៀបតម្លៃ និង 1 បន្ទាប់ពី។

យើងបានអានខ្លះរួចហើយ របៀប PWMដូច្នេះយើងរកឃើញការចុះឈ្មោះដែលត្រូវការនៃកម្មវិធីកំណត់ម៉ោងទីពីរដោយស្វែងរកក្នុងសៀវភៅណែនាំសម្រាប់ឃ្លានេះ (18.6.8 - TIMx_CCMR1)៖

110៖ របៀប PWM ដំបូង – នៅពេលរាប់ពីបាតដល់កំពូល ប៉ុស្តិ៍ទីមួយដំណើរការខណៈពេលដែល TIMx_CNT < TIMx_CCR1 ។ បើមិនដូច្នោះទេ ប៉ុស្តិ៍ទីមួយគឺអសកម្ម។ [បន្ថែមទៀតនៅក្នុងឯកសារមានការចម្លងខុសពីកម្មវិធីកំណត់ម៉ោង 1] 111៖ របៀប PWM ទីពីរ – នៅពេលរាប់ពីបាតទៅកំពូល ឆានែលទីមួយគឺអសកម្មខណៈពេលដែល TIMx_CNT < TIMx_CCR1 ។ បើមិនដូច្នោះទេ ប៉ុស្តិ៍ទីមួយគឺសកម្ម។

ដោយសារ LEDs ត្រូវបានភ្ជាប់ទៅ MK ដោយ cathodes របៀបទីពីរសាកសមនឹងយើង (ទីមួយផងដែរ ប៉ុន្តែយើងមិនទាន់ដឹងនៅឡើយ)។

Bit 3 OC1PE៖ បើកដំណើរការ pin 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;

អ្វីដែលនៅសល់គឺត្រូវបើកការសន្និដ្ឋាន និងកម្មវិធីកំណត់ម៉ោងទីពីរដោយខ្លួនឯង។ បញ្ហាទីមួយត្រូវបានដោះស្រាយដោយការចុះឈ្មោះ ចាប់យក/ប្រៀបធៀប អនុញ្ញាត៖ មាន​ពីរ បី​ប៉ុស្តិ៍​ដែល​រាយប៉ាយ​ពាសពេញ​ពួកវា​ដោយ​មិន​ស៊ីមេទ្រី។ នៅទីនេះយើងក៏អាចរៀនថាវាអាចធ្វើទៅបានដើម្បីផ្លាស់ប្តូរបន្ទាត់រាងប៉ូលនៃសញ្ញា, i.e. ជាគោលការណ៍ វាអាចប្រើរបៀប 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;

ចូរយើងសរសេរ analogue សាមញ្ញនៃ AnalogWrite() ដែលនឹងផ្ទេរតម្លៃជាក់ស្តែងទៅកម្មវិធីកំណត់ម៉ោងសម្រាប់ការប្រៀបធៀប។ បញ្ជីឈ្មោះត្រូវបានព្យាករណ៍ ចាប់យក/ប្រៀបធៀបការចុះឈ្មោះមានពីរនៃពួកវាសម្រាប់ឆានែលនីមួយៗ៖ លំដាប់ទាប 8 ប៊ីតនៅក្នុង TIM2_CCRxL និងលំដាប់ខ្ពស់នៅក្នុង TIM2_CCRxH ។ ដោយសារយើងបានបង្កើត PWM 8 ប៊ីត វាគ្រប់គ្រាន់ហើយក្នុងការសរសេរតែប៊ីតដែលមិនសូវសំខាន់៖

#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 ចំនួនប្រាំបីទៅនឹងឧបករណ៍កំណត់ម៉ោងទីពីរនៅក្នុងរបៀប PWM ហើយធ្វើឱ្យពួកវាបង្ហាញពណ៌ខុសៗគ្នា។ វាត្រូវបានផ្អែកលើគោលគំនិតនៃ LED multiplexing ដែលគឺថាប្រសិនបើអ្នកបើក និងបិទ LEDs យ៉ាងលឿន វានឹងហាក់បីដូចជាពួកយើងថាពួកគេបើកជានិច្ច (ភាពអត់ធ្មត់នៃចក្ខុវិស័យនិចលភាពនៃការយល់ឃើញដែលមើលឃើញ) ។ ខ្ញុំធ្លាប់ធ្វើ អ្វីមួយដូចនេះនៅលើ Arduino.

ក្បួនដោះស្រាយការងារមើលទៅដូចនេះ៖

• ភ្ជាប់ anode នៃ RGB LED ដំបូង;
• បំភ្លឺវាបញ្ជូនសញ្ញាចាំបាច់ទៅ cathodes;
• រង់ចាំរហូតដល់ចុងបញ្ចប់នៃវដ្ត PWM;
• ភ្ជាប់ anode នៃ LED RGB ទីពីរ;
• បំភ្លឺវា...

អញ្ចឹង។ល។ ជាការពិតណាស់សម្រាប់ប្រតិបត្តិការដ៏ស្រស់ស្អាតវាត្រូវបានទាមទារថា anode ត្រូវបានភ្ជាប់ហើយ LED ត្រូវបាន "បញ្ឆេះ" ក្នុងពេលតែមួយ។ មែនហើយឬស្ទើរតែ។ ក្នុងករណីណាក៏ដោយ យើងត្រូវសរសេរកូដដែលនឹងបញ្ចេញតម្លៃជាបីប៉ុស្តិ៍នៃកម្មវិធីកំណត់ម៉ោងទីពីរ ផ្លាស់ប្តូរពួកវានៅពេល UEV ត្រូវបានទៅដល់ ហើយក្នុងពេលតែមួយផ្លាស់ប្តូរ RGB LED ដែលសកម្មបច្ចុប្បន្ន។

ដោយសារការប្តូរ LED គឺដោយស្វ័យប្រវត្តិ យើងត្រូវបង្កើត "អង្គចងចាំវីដេអូ" ដែលឧបករណ៍ដោះស្រាយការរំខាននឹងទទួលបានទិន្នន័យ។ នេះគឺជាអារេសាមញ្ញមួយ៖

uint8_t colors[8][3];

ដើម្បីផ្លាស់ប្តូរពណ៌នៃ LED ជាក់លាក់មួយវានឹងគ្រប់គ្រាន់ដើម្បីសរសេរតម្លៃដែលត្រូវការទៅក្នុងអារេនេះ។ ហើយអថេរនឹងទទួលខុសត្រូវចំពោះចំនួន LED សកម្ម

uint8_t cnt;

Demux

សម្រាប់ការពហុគុណត្រឹមត្រូវ យើងត្រូវការ ចំហរគ្រប់គ្រាន់ CD74HC238 demultiplexer ។ Demultiplexer - បន្ទះឈីបដែលអនុវត្តប្រតិបត្តិករនៅក្នុងផ្នែករឹង <<. តាមរយៈម្ជុលបញ្ចូលបី (ប៊ីត 0, 1 និង 2) យើងផ្តល់លេខបីប៊ីត X ហើយជាការឆ្លើយតប វាធ្វើឱ្យលេខលទ្ធផលសកម្ម (1<<X) ធាតុបញ្ចូលដែលនៅសល់នៃបន្ទះឈីបត្រូវបានប្រើដើម្បីធ្វើមាត្រដ្ឋានការរចនាទាំងមូល។ យើងត្រូវការបន្ទះឈីបនេះមិនត្រឹមតែកាត់បន្ថយចំនួនម្ជុលដែលកាន់កាប់របស់ microcontroller ប៉ុណ្ណោះទេ ប៉ុន្តែក៏សម្រាប់សុវត្ថិភាពផងដែរ - ដើម្បីកុំឱ្យបើក LEDs ច្រើនជាងការដែលអាចធ្វើបានដោយចៃដន្យ និងមិនឆេះ MK ។ បន្ទះឈីបនេះមានតម្លៃមួយកាក់មួយកាក់ ហើយគួររក្សាទុកក្នុងទូដាក់ថ្នាំនៅផ្ទះរបស់អ្នកជានិច្ច។

CD74HC238 របស់យើងនឹងទទួលខុសត្រូវក្នុងការផ្គត់ផ្គង់វ៉ុលទៅ anode នៃ LED ដែលចង់បាន។ នៅក្នុង multiplex ពេញលេញ វានឹងផ្គត់ផ្គង់វ៉ុលទៅជួរឈរតាមរយៈ P-MOSFET ប៉ុន្តែនៅក្នុងការបង្ហាញនេះ វាអាចធ្វើទៅបានដោយផ្ទាល់ ដោយសារតែ វាគូរ 20 mA នេះបើយោងតាម ​​​​ ការវាយតម្លៃអតិបរមាដាច់ខាត នៅក្នុងឯកសារទិន្នន័យ។ ពី សន្លឹកទិន្នន័យ CD74HC238 យើងត្រូវការ pinouts និងសន្លឹកបន្លំនេះ៖

H = កម្រិតវ៉ុលខ្ពស់, L = កម្រិតតង់ស្យុងទាប, X – មិនខ្វល់

យើងភ្ជាប់ E2 និង E1 ទៅនឹងដី E3, A0, A1 និង A3 ដើម្បីម្ជុល PD5, PC3, PC4 និង PC5 នៃ STM8 ។ ដោយសារតារាងខាងលើមានទាំងកម្រិតទាប និងខ្ពស់ យើងកំណត់រចនាសម្ព័ន្ធម្ជុលទាំងនេះជាម្ជុលរុញ។

PWM

PWM នៅលើកម្មវិធីកំណត់ម៉ោងទីពីរត្រូវបានកំណត់រចនាសម្ព័ន្ធតាមរបៀបដូចគ្នានឹងរឿងមុនដែរដោយមានភាពខុសគ្នាពីរ៖

ដំបូងយើងត្រូវបើកការរំខាននៅលើ ធ្វើបច្ចុប្បន្នភាពព្រឹត្តិការណ៍ (UEV) ដែលនឹងហៅមុខងារដែលបិទបើក LED សកម្ម។ នេះត្រូវបានធ្វើដោយការផ្លាស់ប្តូរប៊ីត ធ្វើឱ្យទាន់សម័យការរំខាន បើកដំណើរការ នៅក្នុងការចុះឈ្មោះដែលមានឈ្មោះប្រាប់

រំខានការចុះឈ្មោះ

#define TIM2_IER   *(volatile uint8_t *)0x005303

//enable interrupt
TIM2_IER = 1;

ភាពខុសគ្នាទីពីរគឺទាក់ទងទៅនឹងបាតុភូតនៃការគុណដូចជា ខ្មោច - ពន្លឺប៉ារ៉ាស៊ីតនៃ diodes ។ ក្នុងករណីរបស់យើង វាអាចលេចឡើងដោយសារតែការពិតដែលថាកម្មវិធីកំណត់ម៉ោងដែលបណ្តាលឱ្យមានការរំខាននៅលើ 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 ផ្លាស់ប្តូរឈ្មោះលំនាំដើមនៃមុខងារដែលទទួលខុសត្រូវចំពោះការរំខានលេខ 13 (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;
}

អ្វីដែលនៅសល់គឺដើម្បីបើកការរំខាន។ នេះត្រូវបានធ្វើដោយប្រើពាក្យបញ្ជា assembler rim - អ្នកនឹងត្រូវរកមើលវានៅក្នុង សៀវភៅណែនាំកម្មវិធី:

//enable interrupts
_asm("rim");

ពាក្យបញ្ជាអ្នកដំឡើងមួយទៀតគឺ sim - បិទការរំខាន។ ពួកគេត្រូវតែបិទខណៈពេលដែលតម្លៃថ្មីកំពុងត្រូវបានសរសេរទៅ "អង្គចងចាំវីដេអូ" ដូច្នេះការរំខានដែលកើតឡើងនៅពេលខុសមិនធ្វើឱ្យខូចអារេនោះទេ។

លេខកូដទាំងអស់ - នៅលើ GitHub.

ប្រសិនបើយ៉ាងហោចណាស់មាននរណាម្នាក់យល់ថាអត្ថបទនេះមានប្រយោជន៍ នោះខ្ញុំមិនបានសរសេរវាដោយឥតប្រយោជន៍ទេ។ ខ្ញុំនឹងរីករាយក្នុងការទទួលបានមតិយោបល់ និងការកត់សម្គាល់ ខ្ញុំនឹងព្យាយាមឆ្លើយគ្រប់យ៉ាង

ប្រភព: www.habr.com