В ສ່ວນທໍາອິດ ຂ້າພະເຈົ້າໄດ້ພະຍາຍາມບອກນັກວິສະວະກອນອີເລັກໂທຣນິກທີ່ເຕີບໃຫຍ່ມາຈາກກາງເກງ Arduino ແນວໃດແລະເປັນຫຍັງພວກເຂົາຄວນອ່ານເອກະສານຂໍ້ມູນແລະເອກະສານອື່ນໆສໍາລັບ microcontrollers. ຂໍ້ຄວາມໄດ້ກາຍເປັນຂະຫນາດໃຫຍ່, ສະນັ້ນຂ້າພະເຈົ້າສັນຍາວ່າຈະສະແດງຕົວຢ່າງການປະຕິບັດໃນບົດຄວາມແຍກຕ່າງຫາກ. ເອີ ເຂົາເອີ້ນຕົນເອງວ່າເຫັດນົມ...

ມື້ນີ້ຂ້ອຍຈະສະແດງວິທີການໃຊ້ datasheets ເພື່ອແກ້ໄຂຂ້ອນຂ້າງງ່າຍດາຍ, ແຕ່ມີຄວາມຈໍາເປັນສໍາລັບໂຄງການຈໍານວນຫຼາຍ, ວຽກງານກ່ຽວກັບ STM32 (Blue Pill) ແລະ STM8 controllers. ໂຄງການ demo ທັງຫມົດແມ່ນອຸທິດຕົນເພື່ອ LEDs favorite ຂອງຂ້າພະເຈົ້າ, ພວກເຮົາຈະເຮັດໃຫ້ມີແສງໃຫ້ເຂົາເຈົ້າໃນຂະຫນາດໃຫຍ່, ສໍາລັບການທີ່ພວກເຮົາຈະຕ້ອງໄດ້ນໍາໃຊ້ທຸກປະເພດຂອງອຸປະກອນເສີມທີ່ຫນ້າສົນໃຈ.

ຂໍ້ຄວາມອີກເທື່ອຫນຶ່ງໄດ້ກາຍເປັນຂະຫນາດໃຫຍ່, ດັ່ງນັ້ນເພື່ອຄວາມສະດວກຂ້ອຍກໍາລັງສ້າງເນື້ອຫາ:

STM32 Blue Pill: 16 LEDs ກັບໄດເວີ DM634
STM8: ຕັ້ງຄ່າຫົກ pin PWM
STM8: 8 RGB LEDs ໃນສາມ pins, ຂັດຂວາງ

ການປະຕິເສດ: ຂ້ອຍບໍ່ແມ່ນວິສະວະກອນ, ຂ້ອຍບໍ່ໄດ້ທໍາທ່າວ່າມີຄວາມຮູ້ເລິກເຊິ່ງໃນເອເລັກໂຕຣນິກ, ບົດຄວາມແມ່ນມີຈຸດປະສົງສໍາລັບນັກສມັກເລ່ນເຊັ່ນຂ້ອຍ. ໃນຄວາມເປັນຈິງ, ຂ້າພະເຈົ້າໄດ້ພິຈາລະນາຕົນເອງສອງປີກ່ອນເປັນຜູ້ຊົມເປົ້າຫມາຍ. ຖ້າໃຜຜູ້ຫນຶ່ງບອກຂ້ອຍວ່າແຜ່ນຂໍ້ມູນໃນຊິບທີ່ບໍ່ຄຸ້ນເຄີຍບໍ່ຫນ້າຢ້ານທີ່ຈະອ່ານ, ຂ້ອຍຈະບໍ່ໃຊ້ເວລາຫຼາຍໃນການຊອກຫາລະຫັດບາງຢ່າງໃນອິນເຕີເນັດແລະປະດິດໄມ້ຄ້ອນທີ່ມີມີດຕັດແລະ tape adhesive.

ຈຸດ​ສຸມ​ຂອງ​ບົດ​ຄວາມ​ນີ້​ແມ່ນ​ຢູ່​ໃນ​ແຜ່ນ​ຂໍ້​ມູນ​, ບໍ່​ແມ່ນ​ໂຄງ​ການ​, ສະ​ນັ້ນ​ລະ​ຫັດ​ອາດ​ຈະ​ບໍ່​ແມ່ນ​ຫຼາຍ​ແລະ​ມັກ​ຈະ​ແຄບ​. ໂຄງການດ້ວຍຕົນເອງແມ່ນງ່າຍດາຍຫຼາຍ, ເຖິງແມ່ນວ່າເຫມາະສົມສໍາລັບຄົນຮູ້ຈັກຄັ້ງທໍາອິດກັບຊິບໃຫມ່.

ຂ້າ​ພະ​ເຈົ້າ​ຫວັງ​ວ່າ​ບົດ​ຄວາມ​ຂອງ​ຂ້າ​ພະ​ເຈົ້າ​ຈະ​ຊ່ວຍ​ໃຫ້​ຜູ້​ໃດ​ຜູ້​ຫນຶ່ງ​ຢູ່​ໃນ​ຂັ້ນ​ຕອນ​ທີ່​ຄ້າຍ​ຄື​ກັນ​ຂອງ immersion ໃນ hobby ໄດ້.

STM32

16 LEDs ກັບ DM634 ແລະ SPI

ໂຄງການຂະຫນາດນ້ອຍທີ່ໃຊ້ Blue Pill (STM32F103C8T6) ແລະໄດເວີ LED DM634. ການນໍາໃຊ້ແຜ່ນຂໍ້ມູນ, ພວກເຮົາຈະຄິດອອກໄດເວີ, ພອດ STM IO ແລະຕັ້ງຄ່າ SPI.

DM634

ຊິບໄຕ້ຫວັນທີ່ມີ 16 16-bit PWM ຜົນຜະລິດ, ສາມາດເຊື່ອມຕໍ່ໃນຕ່ອງໂສ້. ຮູບແບບ 12-bit ຕ່ໍາສຸດແມ່ນເປັນທີ່ຮູ້ຈັກຈາກໂຄງການພາຍໃນປະເທດ ກະເປົ໋າ. ໃນເວລາຫນຶ່ງ, ການເລືອກລະຫວ່າງ DM63x ແລະ TLC5940 ທີ່ມີຊື່ສຽງ, ຂ້າພະເຈົ້າໄດ້ເລືອກ DM ສໍາລັບເຫດຜົນຫຼາຍຢ່າງ: 1) TLC ໃນ Aliexpress ແມ່ນແນ່ນອນຂອງປອມ, ແຕ່ນີ້ບໍ່ແມ່ນ; 2) DM ມີ PWM ອັດຕະໂນມັດທີ່ມີເຄື່ອງກໍາເນີດຄວາມຖີ່ຂອງຕົນເອງ; 3) ມັນສາມາດໄດ້ຮັບການຊື້ລາຄາຖືກໃນ Moscow, ແທນທີ່ຈະລໍຖ້າ parcel ຈາກ Ali. ແລະ, ແນ່ນອນ, ມັນເປັນເລື່ອງທີ່ຫນ້າສົນໃຈທີ່ຈະຮຽນຮູ້ວິທີການຄວບຄຸມຊິບດ້ວຍຕົນເອງ, ແທນທີ່ຈະໃຊ້ຫ້ອງສະຫມຸດທີ່ກຽມພ້ອມ. ໃນປັດຈຸບັນ chip ໄດ້ຖືກນໍາສະເຫນີສ່ວນໃຫຍ່ແມ່ນຢູ່ໃນຊຸດ SSOP24; ມັນງ່າຍທີ່ຈະ solder ກັບອະແດບເຕີ.

ເນື່ອງຈາກຜູ້ຜະລິດແມ່ນຊາວໄຕ້ຫວັນ, ເອ​ກະ​ສານ​ຂໍ້​ມູນ​ chip ແມ່ນຂຽນເປັນພາສາອັງກິດຈີນ, ຊຶ່ງຫມາຍຄວາມວ່າມັນຈະມ່ວນ. ທໍາອິດພວກເຮົາເບິ່ງ pinout (ປັກໝຸດການເຊື່ອມຕໍ່) ເພື່ອ​ເຂົ້າ​ໃຈ​ວ່າ​ຂາ​ໃດ​ທີ່​ຈະ​ເຊື່ອມ​ຕໍ່​ກັບ​ສິ່ງ​ທີ່​, ແລະ​ລາຍ​ລະ​ອຽດ​ຂອງ pins (ລາຍລະອຽດ Pin). 16 ເຂັມ:

ແຫຼ່ງ DC Sink (Open Drain)

ຈົມລົງ / ເປີດ-ລະບາຍນ້ຳອອກ - ລະບາຍ; ແຫຼ່ງກະແສກະແສໄຟຟ້າ; ຜົນຜະລິດແມ່ນເຊື່ອມຕໍ່ກັບຫນ້າດິນໃນສະພາບການເຄື່ອນໄຫວ - LEDs ແມ່ນເຊື່ອມຕໍ່ກັບໄດເວີໂດຍ cathodes. ໄຟຟ້າ, ແນ່ນອນ, ບໍ່ແມ່ນ "ທໍ່ລະບາຍນ້ໍາເປີດ" (ເປີດລະບາຍ), ແຕ່ໃນ datasheets ການກໍານົດນີ້ສໍາລັບ pins ໃນຮູບແບບການລະບາຍແມ່ນພົບເຫັນເລື້ອຍໆ.

ຕົວຕ້ານທານພາຍນອກລະຫວ່າງ REXT ແລະ GND ເພື່ອກໍານົດມູນຄ່າປະຈຸບັນຜົນຜະລິດ

ຕົວຕ້ານທານອ້າງອີງຖືກຕິດຕັ້ງຢູ່ລະຫວ່າງ pin REXT ແລະດິນ, ເຊິ່ງຄວບຄຸມຄວາມຕ້ານທານພາຍໃນຂອງຜົນໄດ້ຮັບ, ເບິ່ງເສັ້ນສະແດງໃນຫນ້າ 9 ຂອງເອກະສານຂໍ້ມູນ. ໃນ DM634, ການຕໍ່ຕ້ານນີ້ຍັງສາມາດຄວບຄຸມໂດຍຊອບແວ, ກໍານົດຄວາມສະຫວ່າງໂດຍລວມ (ຄວາມສະຫວ່າງທົ່ວໂລກ); ຂ້າພະເຈົ້າຈະບໍ່ເຂົ້າໄປໃນລາຍລະອຽດໃນບົດຄວາມນີ້, ຂ້າພະເຈົ້າພຽງແຕ່ຈະໃສ່ຕົວຕ້ານທານ 2.2 - 3 kOhm ຢູ່ທີ່ນີ້.

ເພື່ອເຂົ້າໃຈວິທີການຄວບຄຸມຊິບ, ໃຫ້ເບິ່ງລາຍລະອຽດຂອງການໂຕ້ຕອບອຸປະກອນ:

ແມ່ນແລ້ວ, ນີ້ແມ່ນພາສາອັງກິດຈີນໃນລັດສະຫມີພາບທັງຫມົດ. ການແປນີ້ແມ່ນມີບັນຫາ, ທ່ານສາມາດເຂົ້າໃຈມັນຖ້າທ່ານຕ້ອງການ, ແຕ່ມີວິທີອື່ນ - ເບິ່ງວິທີການເຊື່ອມຕໍ່ກັບ TLC5940 ທີ່ຄ້າຍຄືກັນທີ່ອະທິບາຍໄວ້ໃນເອກະສານຂໍ້ມູນ:

... ພຽງແຕ່ສາມ pins ຈໍາເປັນຕ້ອງໄດ້ປ້ອນຂໍ້ມູນເຂົ້າໄປໃນອຸປະກອນ. ຂອບທີ່ເພີ່ມຂຶ້ນຂອງສັນຍານ SCLK ປ່ຽນຂໍ້ມູນຈາກ PIN SIN ໄປຫາທະບຽນພາຍໃນ. ຫຼັງຈາກຂໍ້ມູນທັງໝົດຖືກໂຫລດແລ້ວ, ສັນຍານ XLAT ສູງສັ້ນຈະຈັບຂໍ້ມູນທີ່ຖືກໂອນເຂົ້າຢູ່ໃນທະບຽນພາຍໃນ. ທະບຽນພາຍໃນແມ່ນປະຕູທີ່ຖືກກະຕຸ້ນໂດຍລະດັບສັນຍານ XLAT. ຂໍ້​ມູນ​ທັງ​ຫມົດ​ແມ່ນ​ໄດ້​ຮັບ​ການ​ຖ່າຍ​ໂອນ​ທີ່​ສໍາ​ຄັນ​ທີ່​ສຸດ​ນ້ອຍ​ທໍາ​ອິດ​.

Latch - ສະ​ປັດ / ສະ​ຕິກ / lock​.
ຂອບ​ເພີ່ມ​ຂຶ້ນ - ແຂບຊັ້ນນໍາຂອງກໍາມະຈອນ
MSB ກ່ອນ – ທີ່​ສໍາ​ຄັນ​ທີ່​ສຸດ (ຊ້າຍ​ສຸດ​) ບິດ​ໄປ​ຫນ້າ​.
ຂໍ້ມູນໂມງ - ສົ່ງ​ຂໍ້​ມູນ​ຕາມ​ລໍາ​ດັບ (ບິດ​ໂດຍ​ນ້ອຍ​)​.

ຄໍາ ລອກ ມັກຈະພົບເຫັນຢູ່ໃນເອກະສານສໍາລັບຊິບແລະຖືກແປດ້ວຍວິທີຕ່າງໆ, ດັ່ງນັ້ນເພື່ອຄວາມເຂົ້າໃຈຂ້ອຍຈະອະນຸຍາດໃຫ້ຕົວເອງ.

ໂຄງ​ການ​ການ​ສຶກ​ສາ​ຂະ​ຫນາດ​ນ້ອຍ​ໄດເວີ LED ເປັນສິ່ງຈໍາເປັນສໍາລັບການລົງທະບຽນການປ່ຽນແປງ. "ປ່ຽນ" (ປ່ຽນແປງ) ໃນຊື່ - ການເຄື່ອນໄຫວ bitwise ຂອງຂໍ້ມູນພາຍໃນອຸປະກອນ: ແຕ່ລະບິດໃຫມ່ shoved ພາຍໃນ pushes ໂສ້ທັງຫມົດໄປຂ້າງຫນ້າຂອງມັນ. ເນື່ອງຈາກວ່າບໍ່ມີໃຜຕ້ອງການທີ່ຈະສັງເກດເຫັນການກະພິບ chaotic ຂອງ LEDs ໃນລະຫວ່າງການປ່ຽນ, ຂະບວນການເກີດຂຶ້ນໃນທະບຽນ buffer ແຍກອອກຈາກບັນທຶກການເຮັດວຽກໂດຍ damper (ລອກ) ແມ່ນປະເພດຂອງຫ້ອງລໍຖ້າທີ່ bits ຖືກຈັດລຽງຕາມລໍາດັບທີ່ຕ້ອງການ. ເມື່ອທຸກສິ່ງທຸກຢ່າງກຽມພ້ອມ, shutter ເປີດແລະ bits ໄປເຮັດວຽກ, ທົດແທນຊຸດທີ່ຜ່ານມາ. ຄໍາ ລອກ ໃນເອກະສານສໍາລັບ microcircuits ເກືອບສະເຫມີຫມາຍຄວາມວ່າ damper ດັ່ງກ່າວ, ບໍ່ວ່າມັນຈະຖືກນໍາໃຊ້ໃນການປະສົມປະສານໃດ.

ດັ່ງນັ້ນ, ການໂອນຂໍ້ມູນໄປຍັງ DM634 ແມ່ນປະຕິບັດເຊັ່ນນີ້: ກໍານົດການປ້ອນຂໍ້ມູນ DAI ກັບຄ່າຂອງບິດທີ່ສໍາຄັນຂອງ LED ໄກ, ດຶງ DCK ຂຶ້ນແລະລົງ; ກໍານົດການປ້ອນຂໍ້ມູນ DAI ກັບຄ່າຂອງບິດຕໍ່ໄປ, ດຶງ DCK; ແລະອື່ນໆຈົນກ່ວາ bits ທັງຫມົດໄດ້ຖືກຖ່າຍທອດ (ໂມງເຂົ້າ), ຫຼັງຈາກນັ້ນພວກເຮົາດຶງ LAT. ນີ້ສາມາດເຮັດໄດ້ດ້ວຍຕົນເອງ (bit-bang), ແຕ່ມັນກໍ່ດີກວ່າທີ່ຈະໃຊ້ການໂຕ້ຕອບ SPI ທີ່ເຫມາະສົມໂດຍສະເພາະສໍາລັບການນີ້, ເນື່ອງຈາກວ່າມັນຖືກນໍາສະເຫນີຢູ່ໃນ STM32 ຂອງພວກເຮົາໃນສອງສໍາເນົາ.

ເມັດສີຟ້າ STM32F103

ການແນະນໍາ: ຕົວຄວບຄຸມ STM32 ແມ່ນມີຄວາມຊັບຊ້ອນຫຼາຍກ່ວາ Atmega328 ຫຼາຍກວ່າທີ່ພວກມັນເບິ່ງຄືວ່າເປັນຕາຢ້ານ. ຍິ່ງໄປກວ່ານັ້ນ, ສໍາລັບເຫດຜົນຂອງການປະຫຍັດພະລັງງານ, ເກືອບທຸກອຸປະກອນຖືກປິດໃນຕອນເລີ່ມຕົ້ນ, ແລະຄວາມຖີ່ຂອງໂມງແມ່ນ 8 MHz ຈາກແຫຼ່ງພາຍໃນ. ໂຊກດີ, ນັກຂຽນໂປລແກລມ STM ຂຽນລະຫັດທີ່ນໍາເອົາຊິບເຖິງ "ການຄິດໄລ່" 72 MHz, ແລະຜູ້ຂຽນຂອງ IDE ທັງຫມົດທີ່ຂ້ອຍຮູ້ລວມຢູ່ໃນຂັ້ນຕອນການເລີ່ມຕົ້ນ, ດັ່ງນັ້ນພວກເຮົາບໍ່ຈໍາເປັນຕ້ອງໂມງ (ແຕ່. ເຈົ້າສາມາດຖ້າຫາກວ່າທ່ານຕ້ອງການແທ້ໆ). ແຕ່ທ່ານຈະຕ້ອງເປີດອຸປະກອນຕໍ່.

ເອກະສານ: Blue Pill ມີຊິບ STM32F103C8T6 ທີ່ນິຍົມ, ມີສອງເອກະສານທີ່ເປັນປະໂຫຍດສໍາລັບມັນ:

• Data Sheet ສໍາລັບ microcontrollers STM32F103x8 ແລະ STM32F103xB;
• ຄູ່ມືການອ້າງອີງ ສໍາລັບເສັ້ນ STM32F103 ທັງຫມົດແລະອື່ນໆ.

ໃນເອກະສານຂໍ້ມູນພວກເຮົາອາດຈະສົນໃຈ:

• Pinouts - chip pinouts - ໃນກໍລະນີທີ່ພວກເຮົາຕັດສິນໃຈເຮັດກະດານດ້ວຍຕົນເອງ;
• ແຜນທີ່ຫນ່ວຍຄວາມຈໍາ - ແຜນທີ່ຫນ່ວຍຄວາມຈໍາສໍາລັບຊິບສະເພາະ. ຄູ່ມືອ້າງອີງມີແຜນທີ່ສໍາລັບເສັ້ນທັງຫມົດ, ແລະມັນກ່າວເຖິງການລົງທະບຽນທີ່ພວກເຮົາບໍ່ມີ.
• ຕາຕະລາງຄໍານິຍາມ PIN - ລາຍຊື່ຫນ້າທີ່ຕົ້ນຕໍແລະທາງເລືອກຂອງ pins; ສໍາລັບ "ຢາເມັດສີຟ້າ" ທ່ານສາມາດຊອກຫາຮູບພາບທີ່ສະດວກກວ່າໃນອິນເຕີເນັດດ້ວຍບັນຊີລາຍຊື່ຂອງ pins ແລະຫນ້າທີ່ຂອງມັນ. ດັ່ງນັ້ນ, ພວກເຮົາທັນທີ google Blue Pill pinout ແລະຮັກສາຮູບນີ້ຢູ່ໃນມື:

NB: ມີຂໍ້ຜິດພາດໃນຮູບພາບຈາກອິນເຕີເນັດ, ເຊິ່ງໄດ້ຖືກບັນທຶກໄວ້ໃນຄໍາເຫັນ, ຂອບໃຈສໍາລັບສິ່ງນັ້ນ. ຮູບພາບໄດ້ຖືກປ່ຽນແທນ, ແຕ່ນີ້ແມ່ນບົດຮຽນ - ມັນດີກວ່າທີ່ຈະກວດເບິ່ງຂໍ້ມູນບໍ່ແມ່ນຈາກເອກະສານຂໍ້ມູນ.

ພວກເຮົາເອົາແຜ່ນຂໍ້ມູນ, ເປີດຄູ່ມືການອ້າງອິງ, ແລະຈາກນີ້ໄປພວກເຮົາໃຊ້ພຽງແຕ່ມັນ.
ຂັ້ນຕອນ: ພວກເຮົາຈັດການກັບວັດສະດຸປ້ອນ / ຜົນຜະລິດມາດຕະຖານ, ຕັ້ງຄ່າ SPI, ເປີດອຸປະກອນຕໍ່ເນື່ອງທີ່ຈໍາເປັນ.

Input Output

ໃນ Atmega328, I/O ຖືກປະຕິບັດຢ່າງງ່າຍດາຍ, ນັ້ນແມ່ນເຫດຜົນທີ່ຄວາມອຸດົມສົມບູນຂອງທາງເລືອກ STM32 ສາມາດສັບສົນ. ໃນປັດຈຸບັນພວກເຮົາພຽງແຕ່ຕ້ອງການບົດສະຫຼຸບ, ແຕ່ເຖິງແມ່ນວ່າສິ່ງເຫຼົ່ານີ້ມີສີ່ທາງເລືອກ:

open drain, push-pull, ທາງເລືອກ push-pull, ທາງເລືອກ open drain

"ດຶງ-ຍູ້" (ຍູ້-ດຶງ) ແມ່ນຜົນຜະລິດປົກກະຕິຈາກ Arduino, pin ສາມາດເອົາຄ່າໄດ້ທັງ HIGH ຫຼື LOW. ແຕ່ມີ "ລະບາຍນ້ໍາເປີດ" ມີ ຄວາມຫຍຸ້ງຍາກ, ເຖິງແມ່ນວ່າໃນຄວາມເປັນຈິງທຸກສິ່ງທຸກຢ່າງແມ່ນງ່າຍດາຍຢູ່ທີ່ນີ້:

Output configuration / ເມື່ອພອດຖືກມອບໝາຍໃຫ້ອອກ: / output buffer enabled: / – open drain mode: “0” in the output register enables N-MOS, “1” in the output register leave the port in Hi-Z mode ( P-MOS ບໍ່ໄດ້ເປີດໃຊ້ງານ ) / – ໂຫມດ push-pull: “0” ໃນທະບຽນຜົນຜະລິດເປີດໃຊ້ N-MOS, “1” ໃນບັນທຶກຜົນອອກມາ activates P-MOS.

ຄວາມແຕກຕ່າງທັງໝົດລະຫວ່າງທໍ່ລະບາຍນ້ຳເປີດ (ເປີດລະບາຍ) ຈາກ "ດຶງ​" (ຍູ້-ດຶງ) ແມ່ນວ່າໃນ pin ທໍາອິດບໍ່ສາມາດຍອມຮັບສະຖານະ HIGH ໄດ້: ເມື່ອຂຽນຫນຶ່ງໄປຫາທະບຽນຜົນຜະລິດ, ມັນຈະເຂົ້າໄປໃນໂຫມດຄວາມຕ້ານທານສູງ (impedance ສູງ, Hi-Z). ເມື່ອຂຽນເລກສູນ, pin ປະຕິບັດຕົວດຽວກັນໃນທັງສອງໂຫມດ, ທັງທາງດ້ານເຫດຜົນ ແລະທາງໄຟຟ້າ.

ໃນ​ຮູບ​ແບບ​ຜົນ​ຜະ​ລິດ​ປົກ​ກະ​ຕິ​, pin ພຽງ​ແຕ່​ອອກ​ອາ​ກາດ​ເນື້ອ​ໃນ​ຂອງ​ການ​ຈົດ​ທະ​ບຽນ​ຜົນ​ຜະ​ລິດ​ໄດ້​. ໃນ "ທາງເລືອກ" ມັນຖືກຄວບຄຸມໂດຍອຸປະກອນຕໍ່ພ່ວງທີ່ສອດຄ້ອງກັນ (ເບິ່ງ 9.1.4):

ຖ້າພອດບິດຖືກຕັ້ງຄ່າເປັນ PIN ຟັງຊັນສະຫຼັບ, ຕົວລົງທະບຽນ PIN ຈະຖືກປິດໃຊ້ງານ ແລະ pin ແມ່ນເຊື່ອມຕໍ່ກັບ pin peripheral.

ການທໍາງານທາງເລືອກຂອງແຕ່ລະ pin ແມ່ນອະທິບາຍຢູ່ໃນ ນິຍາມ Pin ແຜ່ນຂໍ້ມູນແມ່ນຢູ່ໃນຮູບທີ່ດາວໂຫລດ. ຕໍ່​ກັບ​ຄໍາ​ຖາມ​ຂອງ​ສິ່ງ​ທີ່​ຈະ​ເຮັດ​ແນວ​ໃດ​ຖ້າ​ຫາກ​ວ່າ pin ມີ​ຫນ້າ​ທີ່​ທາງ​ເລືອກ​ຈໍາ​ນວນ​ຫນຶ່ງ​, ຄໍາ​ຕອບ​ແມ່ນ​ໄດ້​ຮັບ​ໂດຍ footnote ໃນ datasheet​:

ຖ້າອຸປະກອນຕໍ່ພ່ວງຫຼາຍອັນໃຊ້ PIN ດຽວກັນ, ເພື່ອຫຼີກເວັ້ນການຂັດກັນລະຫວ່າງຟັງຊັນທາງເລືອກ, ຄວນໃຊ້ອຸປະກອນຕໍ່ພ່ວງອັນດຽວໃນເວລາດຽວ, ສະຫຼັບໂດຍໃຊ້ໂມງຕໍ່ຂ້າງເປີດໃຫ້ບິດ (ຢູ່ໃນທະບຽນ RCC ທີ່ເຫມາະສົມ).

ສຸດທ້າຍ, pins ໃນຮູບແບບຜົນຜະລິດຍັງມີຄວາມໄວໂມງ. ນີ້ແມ່ນຄຸນສົມບັດການປະຫຍັດພະລັງງານອີກອັນຫນຶ່ງ; ໃນກໍລະນີຂອງພວກເຮົາ, ພວກເຮົາພຽງແຕ່ຕັ້ງມັນໄວ້ສູງສຸດແລະລືມມັນ.

ດັ່ງນັ້ນ: ພວກເຮົາກໍາລັງໃຊ້ SPI, ຊຶ່ງຫມາຍຄວາມວ່າສອງ pins (ມີຂໍ້ມູນແລະສັນຍານໂມງ) ຄວນຈະເປັນ "ຟັງຊັນ push-pull ທາງເລືອກ", ແລະອີກອັນຫນຶ່ງ (LAT) ຄວນຈະເປັນ "ປົກກະຕິ push-pull". ແຕ່ກ່ອນທີ່ຈະມອບຫມາຍໃຫ້ເຂົາເຈົ້າ, ໃຫ້ຈັດການກັບ SPI.

SPI

ໂຄງການການສຶກສາຂະຫນາດນ້ອຍອີກອັນຫນຶ່ງ

SPI ຫຼື Serial Peripheral Interface (serial peripheral interface) ແມ່ນການໂຕ້ຕອບງ່າຍດາຍແລະມີປະສິດທິພາບຫຼາຍສໍາລັບການເຊື່ອມຕໍ່ MK ກັບ MKs ອື່ນໆແລະໂລກພາຍນອກໂດຍທົ່ວໄປ. ຫຼັກການຂອງການດໍາເນີນງານຂອງມັນໄດ້ຖືກອະທິບາຍແລ້ວຂ້າງເທິງ, ບ່ອນທີ່ກ່ຽວກັບໄດເວີ LED ຂອງຈີນ (ໃນຄູ່ມືອ້າງອີງ, ເບິ່ງພາກ 25). SPI ສາມາດດໍາເນີນການຢູ່ໃນຮູບແບບຕົ້ນສະບັບ ("ນາຍ") ແລະທາດ ("ທາດ"). SPI ມີສີ່ຊ່ອງທາງພື້ນຖານ, ເຊິ່ງບໍ່ແມ່ນທັງຫມົດອາດຈະຖືກນໍາໃຊ້:

• MOSI, Master Output / Slave Input: PIN ນີ້ສົ່ງຂໍ້ມູນໃນຮູບແບບແມ່ແບບ, ແລະຮັບຂໍ້ມູນໃນໂຫມດສໍາລອງ;
• MISO, Master Input / Slave Output: ໃນທາງກົງກັນຂ້າມ, ມັນໄດ້ຮັບໃນແມ່ບົດ, ແລະສົ່ງໃນສໍາລອງ;
• SCK, Serial Clock: ກໍານົດຄວາມຖີ່ຂອງການສົ່ງຂໍ້ມູນໃນແມ່ບົດຫຼືໄດ້ຮັບສັນຍານໂມງໃນສໍາລອງ. ການຕີໂດຍພື້ນຖານ;
• SS, Slave Select: ດ້ວຍການຊ່ວຍເຫຼືອຂອງຊ່ອງທາງນີ້, ສໍາລອງຮູ້ວ່າບາງສິ່ງບາງຢ່າງຕ້ອງການຈາກລາວ. ໃນ STM32 ມັນຖືກເອີ້ນວ່າ NSS, ບ່ອນທີ່ N = ລົບ, i.e. ຜູ້ຄວບຄຸມຈະກາຍເປັນທາດຖ້າມີພື້ນທີ່ຢູ່ໃນຊ່ອງທາງນີ້. ມັນປະສົມປະສານໄດ້ດີກັບໂຫມດ Open Drain Output, ແຕ່ນັ້ນແມ່ນເລື່ອງອື່ນ.

ເຊັ່ນດຽວກັນກັບສິ່ງອື່ນ, SPI ໃນ STM32 ແມ່ນອຸດົມສົມບູນໃນຫນ້າທີ່, ເຊິ່ງເຮັດໃຫ້ມັນຍາກທີ່ຈະເຂົ້າໃຈ. ຕົວຢ່າງ, ມັນສາມາດເຮັດວຽກບໍ່ພຽງແຕ່ກັບ SPI, ແຕ່ຍັງມີການໂຕ້ຕອບ I2S, ແລະໃນເອກະສານຄໍາອະທິບາຍຂອງພວກມັນຖືກປະສົມ, ມັນຈໍາເປັນຕ້ອງຕັດສິ່ງທີ່ບໍ່ຈໍາເປັນໃນທັນທີ. ວຽກງານຂອງພວກເຮົາແມ່ນງ່າຍດາຍທີ່ສຸດ: ພວກເຮົາພຽງແຕ່ຕ້ອງການສົ່ງຂໍ້ມູນໂດຍໃຊ້ພຽງແຕ່ MOSI ແລະ SCK. ພວກເຮົາໄປຫາພາກ 25.3.4 (half-duplex communication, half-duplex communication), ບ່ອນທີ່ພວກເຮົາຊອກຫາ 1 ໂມງ ແລະ 1 ສາຍຂໍ້ມູນ unidirectional (1 ສັນຍານໂມງ ແລະ 1 ກະແສຂໍ້ມູນ unidirectional):

ໃນໂຫມດນີ້, ແອັບພລິເຄຊັນໃຊ້ SPI ໃນຮູບແບບການສົ່ງເທົ່ານັ້ນຫຼືຮັບເທົ່ານັ້ນ. / ໂໝດການຖ່າຍທອດຢ່າງດຽວແມ່ນຄ້າຍຄືກັນກັບໂໝດ duplex: ຂໍ້ມູນຖືກສົ່ງຜ່ານ PIN ສົ່ງ (MOSI ໃນໂໝດແມ່ແບບ ຫຼື MISO ໃນໂໝດຂ້າທາດ), ແລະ PIN ຮັບ (MISO ຫຼື MOSI ຕາມລຳດັບ) ສາມາດໃຊ້ເປັນ PIN I/O ປົກກະຕິໄດ້. . ໃນກໍລະນີນີ້, ແອັບພລິເຄຊັນພຽງແຕ່ຕ້ອງການບໍ່ສົນໃຈ Rx buffer (ຖ້າມັນຖືກອ່ານ, ມັນຈະບໍ່ມີຂໍ້ມູນທີ່ຖືກໂອນຢູ່ທີ່ນັ້ນ).

ດີຫຼາຍ, PIN MISO ແມ່ນບໍ່ເສຍຄ່າ, ໃຫ້ເຊື່ອມຕໍ່ສັນຍານ LAT ກັບມັນ. ໃຫ້ເບິ່ງ Slave Select, ເຊິ່ງຢູ່ໃນ STM32 ສາມາດຄວບຄຸມດ້ວຍໂປຣແກຣມ, ເຊິ່ງສະດວກທີ່ສຸດ. ພວກເຮົາອ່ານວັກຂອງຊື່ດຽວກັນຢູ່ໃນພາກ 25.3.1 SPI ຄໍາອະທິບາຍທົ່ວໄປ:

ການຄວບຄຸມຊອບແວ NSS (SSM = 1) / ຂໍ້ມູນການເລືອກສໍາລອງແມ່ນບັນຈຸຢູ່ໃນ SSI bit ຂອງ SPI_CR1 ລົງທະບຽນ. PIN NSS ພາຍນອກຍັງຄົງບໍ່ເສຍຄ່າສໍາລັບຄວາມຕ້ອງການຂອງແອັບພລິເຄຊັນອື່ນໆ.

ມັນເປັນເວລາທີ່ຈະຂຽນໃສ່ທະບຽນ. ຂ້ອຍຕັດສິນໃຈໃຊ້ SPI2, ຊອກຫາທີ່ຢູ່ພື້ນຖານຂອງມັນຢູ່ໃນເອກະສານຂໍ້ມູນ - ໃນພາກ 3.3 Memory Map:

ແລ້ວ, ໃຫ້ເລີ່ມຕົ້ນ:

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

ເປີດພາກ 25.3.3 ດ້ວຍຫົວຂໍ້ການອະທິບາຍດ້ວຍຕົນເອງ “ການກຳນົດຄ່າ SPI ໃນໂໝດແມ່ບົດ”:

1. ຕັ້ງຄວາມຖີ່ຂອງໂມງ serial ດ້ວຍ bits BR[2:0] ໃນທະບຽນ SPI_CR1.

ການລົງທະບຽນຖືກເກັບຢູ່ໃນສ່ວນຄູ່ມືອ້າງອີງຂອງຊື່ດຽວກັນ. ປ່ຽນທີ່ຢູ່ (ທີ່ຢູ່ ຊົດເຊີຍ) ສໍາລັບ CR1 – 0x00, ໂດຍຄ່າເລີ່ມຕົ້ນ bits ທັງຫມົດຖືກລຶບລ້າງ (ປັບຄ່າ 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)

ເນື່ອງຈາກພວກເຮົາກໍາລັງອ່ານເອກະສານຂໍ້ມູນຢູ່ທີ່ນີ້ແລະບໍ່ໄດ້ເບິ່ງ schematics, ໃຫ້ພວກເຮົາເບິ່ງລາຍລະອຽດຂໍ້ຄວາມຂອງ CPOL ແລະ CPHA bits ໃນຫນ້າ 704 (SPI General Description):

ໄລຍະໂມງ ແລະຂົ້ວໂລກ
ການນໍາໃຊ້ CPOL ແລະ CPHA bits ຂອງການລົງທະບຽນ SPI_CR1, ທ່ານສາມາດ programmatically ເລືອກສີ່ການພົວພັນທີ່ໃຊ້ເວລາ. ບິດ CPOL (clock polarity) ຄວບຄຸມສະຖານະຂອງສັນຍານໂມງໃນເວລາທີ່ບໍ່ມີການສົ່ງຂໍ້ມູນ. ບິດນີ້ຄວບຄຸມຮູບແບບຕົ້ນສະບັບແລະສໍາລອງ. ຖ້າ CPOL ຖືກຣີເຊັດ, PIN SCK ແມ່ນຕໍ່າຢູ່ໃນໂໝດພັກຜ່ອນ. ຖ້າບິດ CPOL ຖືກຕັ້ງ, PIN SCK ຈະສູງໃນລະຫວ່າງການພັກຜ່ອນ.
ເມື່ອ CPHA (ໄລຍະໂມງ) ບິດຖືກຕັ້ງ, ສູງບິດດັກ strobe ແມ່ນຂອບທີສອງຂອງສັນຍານ SCK (ຫຼຸດລົງຖ້າ CPOL ຊັດເຈນ, ເພີ່ມຂຶ້ນຖ້າ CPOL ຖືກຕັ້ງ). ຂໍ້ມູນຖືກຈັບໂດຍການປ່ຽນແປງຄັ້ງທີສອງຂອງສັນຍານໂມງ. ຖ້າບິດຂອງ CPHA ແມ່ນຈະແຈ້ງ, ສູງບິດດັກ strobe ແມ່ນຂອບທີ່ເພີ່ມຂຶ້ນຂອງສັນຍານ SCK (ແຂບຫຼຸດລົງຖ້າ CPOL ຖືກຕັ້ງ, ຂອບເພີ່ມຂຶ້ນຖ້າ CPOL ຖືກລ້າງ). ຂໍ້ມູນຖືກຈັບຢູ່ທີ່ການປ່ຽນແປງຄັ້ງທໍາອິດຂອງສັນຍານໂມງ.

ມີການດູດຊຶມຄວາມຮູ້ນີ້, ພວກເຮົາມາສະຫລຸບວ່າທັງສອງບິດຕ້ອງຍັງຄົງເປັນສູນ, ເພາະວ່າ ພວກເຮົາຕ້ອງການໃຫ້ສັນຍານ SCK ຍັງຄົງຕໍ່າເມື່ອບໍ່ໄດ້ໃຊ້, ແລະຂໍ້ມູນຈະຖືກສົ່ງຢູ່ໃນຂອບເຂດທີ່ເພີ່ມຂຶ້ນຂອງກໍາມະຈອນ (ເບິ່ງຮູບ. ຂອບ​ເພີ່ມ​ຂຶ້ນ ໃນເອກະສານຂໍ້ມູນ DM634).

ໂດຍວິທີທາງການ, ໃນທີ່ນີ້ພວກເຮົາໄດ້ພົບກັບຄຸນລັກສະນະຂອງຄໍາສັບໃນເອກະສານ ST ທໍາອິດ: ໃນພວກມັນຄໍາວ່າ "ປັບບິດເປັນສູນ" ຖືກຂຽນ. ເພື່ອ​ປັບ​ໃຫມ່​ເລັກ​ນ້ອຍ​ແລະບໍ່ ເພື່ອອະນາໄມເລັກນ້ອຍ, ເຊັ່ນ, ສໍາລັບການຍົກຕົວຢ່າງ, Atmega.

3. ຕັ້ງ DFF bit ເພື່ອກໍານົດວ່າບລັອກຂໍ້ມູນເປັນຮູບແບບ 8-bit ຫຼື 16-bit

ໂດຍສະເພາະຂ້າພະເຈົ້າເອົາ 16-bit DM634 ເພື່ອບໍ່ໃຫ້ລົບກວນກັບການສົ່ງຂໍ້ມູນ 12-bit PWM, ເຊັ່ນ DM633. ມັນສົມເຫດສົມຜົນທີ່ຈະຕັ້ງ DFF ເປັນອັນດຽວ:

#define DFF         0x0800

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

4. ກຳນົດຄ່າ LSBFIRST bit ຢູ່ໃນທະບຽນ SPI_CR1 ເພື່ອກຳນົດຮູບແບບບລັອກ

LSBFIRST, ຕາມຊື່ຂອງມັນຊີ້ໃຫ້ເຫັນ, ຕັ້ງຄ່າການສົ່ງຜ່ານທີ່ມີນ້ອຍທີ່ສຸດກ່ອນ. ແຕ່ DM634 ຕ້ອງການທີ່ຈະໄດ້ຮັບຂໍ້ມູນເລີ່ມຕົ້ນຈາກນ້ອຍທີ່ສໍາຄັນ. ເພາະສະນັ້ນ, ພວກເຮົາປ່ອຍໃຫ້ມັນຕັ້ງໃຫມ່.

5. ໃນໂຫມດຮາດແວ, ຖ້າຕ້ອງການປ້ອນຂໍ້ມູນຈາກ PIN NSS, ໃຊ້ສັນຍານສູງໃສ່ PIN NSS ໃນລະຫວ່າງລໍາດັບການໂອນ byte ທັງຫມົດ. ໃນໂຫມດຊອບແວ NSS, ໃຫ້ຕັ້ງ SSM ແລະ SSI bits ໃນທະບຽນ SPI_CR1. ຖ້າ PIN 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 ຖືກຕັ້ງຄ່າ, ໃຫ້ຂຽນຫນ້າທີ່ທັນທີທີ່ສົ່ງ bytes ກັບຄົນຂັບ. ສືບຕໍ່ການອ່ານ 25.3.3 “ການຕັ້ງຄ່າ SPI ໃນຮູບແບບຕົ້ນສະບັບ”:

ຄໍາສັ່ງໂອນຂໍ້ມູນ
ການສົ່ງຂໍ້ມູນເລີ່ມຕົ້ນເມື່ອ byte ຖືກຂຽນໄປທີ່ Tx buffer.
byte ຂໍ້ມູນແມ່ນ loaded ເຂົ້າໄປໃນ shift register at ຂະໜານ ໂຫມດ (ຈາກລົດເມພາຍໃນ) ໃນລະຫວ່າງການສົ່ງຂອງ bit ທໍາອິດ, ຫຼັງຈາກນັ້ນມັນຖືກສົ່ງກັບ ລຳດັບ ໂໝດ PIN MOSI, ບິດທຳອິດ ຫຼືສຸດທ້າຍໄປຂ້າງໜ້າ ຂຶ້ນກັບການຕັ້ງຄ່າຂອງ LSBFIRST bit ໃນທະບຽນ CPI_CR1. ທຸງ TXE ຖືກຕັ້ງຫຼັງຈາກການສົ່ງຂໍ້ມູນ ຈາກ Tx buffer ເພື່ອປ່ຽນທະບຽນ, ແລະຍັງສ້າງການຂັດຂວາງຖ້າບິດ TXEIE ໃນທະບຽນ CPI_CR1 ຖືກຕັ້ງ.

ຂ້າພະເຈົ້າໄດ້ເນັ້ນໃສ່ສອງສາມຄໍາໃນການແປພາສາເພື່ອດຶງດູດຄວາມສົນໃຈກັບລັກສະນະຫນຶ່ງຂອງການປະຕິບັດ SPI ໃນຕົວຄວບຄຸມ STM. ໃນ Atmega ທຸງ TXE (Tx ຫວ່າງເປົ່າ, tx ຫວ່າງເປົ່າແລະພ້ອມທີ່ຈະຮັບຂໍ້ມູນ) ຖືກກໍານົດພຽງແຕ່ຫຼັງຈາກ byte ທັງຫມົດໄດ້ຖືກສົ່ງ ພາຍນອກ. ແລະໃນທີ່ນີ້ທຸງນີ້ຖືກຕັ້ງຫຼັງຈາກ byte ໄດ້ຖືກໃສ່ເຂົ້າໄປໃນທະບຽນ shift ພາຍໃນ. ເນື່ອງຈາກມັນຖືກຍູ້ຢູ່ທີ່ນັ້ນດ້ວຍບິດທັງຫມົດໃນເວລາດຽວກັນ (ໃນຂະຫນານ), ແລະຫຼັງຈາກນັ້ນຂໍ້ມູນຖືກໂອນຕາມລໍາດັບ, TXE ຖືກກໍານົດກ່ອນທີ່ byte ຈະຖືກສົ່ງຫມົດ. ນີ້ແມ່ນສິ່ງສໍາຄັນເພາະວ່າ ໃນກໍລະນີຂອງໄດເວີ LED ຂອງພວກເຮົາ, ພວກເຮົາຈໍາເປັນຕ້ອງດຶງ pin LAT ຫຼັງຈາກສົ່ງ всех ຂໍ້ມູນ, i.e. ທຸງ TXE ຢ່າງດຽວຈະບໍ່ພຽງພໍສໍາລັບພວກເຮົາ.

ນີ້ຫມາຍຄວາມວ່າພວກເຮົາຕ້ອງການທຸງອື່ນ. ລອງເບິ່ງ 25.3.7 - “ທຸງສະຖານະ”:

<…>

ທຸງ BUSY
ທຸງ BSY ຖືກຕັ້ງແລະຖືກລຶບລ້າງໂດຍຮາດແວ (ການຂຽນມັນບໍ່ມີຜົນ). ທຸງ BSY ຊີ້ບອກສະຖານະຂອງຊັ້ນການສື່ສານ SPI.
ມັນຣີເຊັດ:
ເມື່ອ​ການ​ໂອນ​ໄດ້​ສໍາ​ເລັດ (ຍົກ​ເວັ້ນ​ໃນ​ຮູບ​ແບບ​ຕົ້ນ​ສະ​ບັບ​ຖ້າ​ຫາກ​ວ່າ​ການ​ໂອນ​ແມ່ນ​ຕໍ່​ເນື່ອງ​)
ເມື່ອ SPI ຖືກປິດໃຊ້ງານ
ເມື່ອ​ມີ​ຄວາມ​ຜິດ​ພາດ​ຮູບ​ແບບ​ຕົ້ນ​ສະ​ບັບ​ເກີດ​ຂຶ້ນ (MODF=1​)
ຖ້າການໂອນບໍ່ຕໍ່ເນື່ອງ, ທຸງ BSY ຈະຖືກລຶບລ້າງລະຫວ່າງແຕ່ລະການໂອນຂໍ້ມູນ

ຕົກລົງ, ນີ້ຈະເປັນປະໂຫຍດ. ໃຫ້ຊອກຫາບ່ອນທີ່ Tx buffer ຕັ້ງຢູ່. ເພື່ອເຮັດສິ່ງນີ້, ອ່ານ "SPI Data Register":

Bits 15:0 DR[15:0] ລົງທະບຽນຂໍ້ມູນ
ຂໍ້ມູນທີ່ໄດ້ຮັບຫຼືຂໍ້ມູນທີ່ຈະສົ່ງ.
ບັນທຶກຂໍ້ມູນແບ່ງອອກເປັນສອງ buffers - ຫນຶ່ງສໍາລັບການຂຽນ (buffer ສົ່ງ) ແລະຫນຶ່ງສໍາລັບການອ່ານ (ຮັບ buffer). ການຂຽນບັນທຶກຂໍ້ມູນຈະຂຽນໄປທີ່ Tx buffer, ແລະການອ່ານຈາກທະບຽນຂໍ້ມູນຈະສົ່ງຄືນຄ່າທີ່ມີຢູ່ໃນ Rx buffer.

ດີ, ແລະລົງທະບຽນສະຖານະພາບ, ບ່ອນທີ່ມີທຸງ 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 ເທົ່າສອງ bytes, ອີງຕາມຈໍານວນຂອງຜົນໄດ້ຮັບຂອງ LED driver, ບາງສິ່ງບາງຢ່າງເຊັ່ນນີ້:

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

ແຕ່ພວກເຮົາຍັງບໍ່ຮູ້ວ່າຈະດຶງ PIN LAT ແນວໃດ, ດັ່ງນັ້ນພວກເຮົາຈະກັບຄືນໄປຫາ I/O.

ການມອບຫມາຍ pins

ໃນ STM32F1, ທະບຽນທີ່ຮັບຜິດຊອບສໍາລັບສະຖານະຂອງ pins ແມ່ນຂ້ອນຂ້າງຜິດປົກກະຕິ. ມັນເປັນທີ່ຊັດເຈນວ່າມີພວກມັນຫຼາຍກ່ວາ 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- bit blocking register (GPIOx_LCKR).

ການລົງທະບຽນສອງອັນທໍາອິດແມ່ນຜິດປົກກະຕິ, ແລະຍັງຂ້ອນຂ້າງບໍ່ສະດວກ, ເພາະວ່າ 16 ຮູສຽບຖືກກະແຈກກະຈາຍໄປທົ່ວພວກມັນໃນຮູບແບບ "ສີ່ບິດຕໍ່ອ້າຍ". ເຫຼົ່ານັ້ນ. pins zero ຫາເຈັດແມ່ນຢູ່ໃນ CRL, ແລະສ່ວນທີ່ເຫຼືອແມ່ນຢູ່ໃນ CRH. ໃນເວລາດຽວກັນ, ການລົງທະບຽນທີ່ຍັງເຫຼືອຢ່າງສໍາເລັດຜົນມີບິດຂອງ pins ທັງຫມົດຂອງທ່າເຮືອ - ສ່ວນຫຼາຍແມ່ນຍັງເຫຼືອເຄິ່ງຫນຶ່ງ "ສະຫງວນ".

ສໍາລັບຄວາມງ່າຍດາຍ, ໃຫ້ເລີ່ມຕົ້ນຈາກໃນຕອນທ້າຍຂອງບັນຊີລາຍຊື່.

ພວກເຮົາບໍ່ຕ້ອງການລົງທະບຽນການຂັດຂວາງ.

ການຕັ້ງຄ່າແລະຣີເຊັດການລົງທະບຽນແມ່ນເປັນເລື່ອງຕະຫລົກທີ່ມັນຊໍ້າກັນບາງສ່ວນ: ທ່ານສາມາດຂຽນທຸກຢ່າງໃນ BSRR ເທົ່ານັ້ນ, ບ່ອນທີ່ 16 bits ສູງກວ່າຈະປັບ pin ເປັນສູນ, ແລະຕົວຕ່ໍາຈະຖືກຕັ້ງເປັນ 1, ຫຼືທ່ານສາມາດ. ໃຊ້ BRR, 16 bits ຕ່ໍາທີ່ພຽງແຕ່ reset pin . ຂ້ອຍມັກທາງເລືອກທີສອງ. ທະບຽນເຫຼົ່ານີ້ມີຄວາມສໍາຄັນເພາະວ່າພວກເຂົາສະຫນອງການເຂົ້າເຖິງປະລໍາມະນູກັບ pins:

Atomic Set ຫຼື Reset
ບໍ່ຈໍາເປັນຕ້ອງປິດການຂັດຂວາງໃນເວລາທີ່ຂຽນໂປລແກລມ GPIOx_ODR ໃນລະດັບບິດ: ຫນຶ່ງຫຼືຫຼາຍບິດສາມາດປ່ຽນແປງໄດ້ດ້ວຍການດໍາເນີນການຂຽນປະລໍາມະນູດຽວ APB2. ນີ້ແມ່ນບັນລຸໄດ້ໂດຍການຂຽນ "1" ໃສ່ຊຸດລົງທະບຽນ / ຣີເຊັດ (GPIOx_BSRR ຫຼື, ສໍາລັບການປັບພຽງແຕ່, GPIOx_BRR) ຂອງບິດທີ່ຕ້ອງໄດ້ຮັບການປ່ຽນແປງ. ບິດອື່ນໆຈະຍັງຄົງບໍ່ປ່ຽນແປງ.

ບັນທຶກຂໍ້ມູນມີຊື່ອະທິບາຍຕົນເອງຂ້ອນຂ້າງ - IDR = ການປ້ອນຂໍ້ມູນ ທິດ​ທາງ​ການ​ຈົດ​ທະ​ບຽນ​, ການ​ຈົດ​ທະ​ບຽນ​ການ​ປ້ອນ​ຂໍ້​ມູນ​; ODR = ຜົນຜະລິດ Direction Register, ລົງທະບຽນຜົນຜະລິດ. ພວກເຮົາຈະບໍ່ຕ້ອງການພວກມັນຢູ່ໃນໂຄງການປະຈຸບັນ.

ແລະສຸດທ້າຍ, ການຄວບຄຸມການລົງທະບຽນ. ເນື່ອງຈາກພວກເຮົາມີຄວາມສົນໃຈໃນ pins SPI ທີສອງ, ຄື PB13, PB14 ແລະ PB15, ພວກເຮົາທັນທີເບິ່ງ CRH:

ແລະພວກເຮົາເຫັນວ່າພວກເຮົາຈະຕ້ອງຂຽນບາງສິ່ງບາງຢ່າງໃນ bits ຈາກ 20 ຫາ 31.

ພວກເຮົາໄດ້ຄິດອອກຂ້າງເທິງສິ່ງທີ່ພວກເຮົາຕ້ອງການຈາກ pins, ດັ່ງນັ້ນໃນທີ່ນີ້ຂ້າພະເຈົ້າຈະເຮັດໂດຍບໍ່ມີການ screenshot, ຂ້າພະເຈົ້າພຽງແຕ່ຈະເວົ້າວ່າ MODE ກໍານົດທິດທາງ (ການປ້ອນຂໍ້ມູນຖ້າຫາກວ່າທັງສອງບິດຖືກຕັ້ງເປັນ 0) ແລະຄວາມໄວ pin (ພວກເຮົາຕ້ອງການ 50MHz, i.e. ທັງສອງ pin ເປັນ "1"), ແລະ CNF ກໍານົດຮູບແບບ: ປົກກະຕິ "push-pull" - 00, "ທາງເລືອກ" - 10. ໂດຍຄ່າເລີ່ມຕົ້ນ, ດັ່ງທີ່ພວກເຮົາເຫັນຂ້າງເທິງ, pins ທັງຫມົດມີບິດທີສາມຈາກລຸ່ມສຸດ (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 ໂດຍ inertia, ມັນເປັນແບບນັ້ນສະ ເໝີ ໄປ, ໃຫ້ມັນຢູ່)

ໃນປັດຈຸບັນທຸກສິ່ງທຸກຢ່າງແມ່ນດີ, ແຕ່ມັນບໍ່ໄດ້ຜົນ. ເນື່ອງຈາກວ່ານີ້ແມ່ນ STM32, ພວກມັນປະຫຍັດໄຟຟ້າ, ຊຶ່ງຫມາຍຄວາມວ່າທ່ານຈໍາເປັນຕ້ອງເປີດໃຊ້ໂມງຂອງອຸປະກອນທີ່ຕ້ອງການ.

ເປີດໃຊ້ໂມງ

ໂມງ, ເຊິ່ງເອີ້ນກັນວ່າໂມງ, ມີໜ້າທີ່ຮັບຜິດຊອບໂມງ. ແລະພວກເຮົາສາມາດສັງເກດເຫັນຕົວຫຍໍ້ RCC ແລ້ວ. ພວກເຮົາຊອກຫາມັນຢູ່ໃນເອກະສານ: ນີ້ແມ່ນ Reset ແລະ Clock Control.

ດັ່ງທີ່ໄດ້ກ່າວໄວ້ຂ້າງເທິງ, ໂຊກດີ, ພາກສ່ວນທີ່ຍາກທີ່ສຸດຂອງຫົວຂໍ້ໂມງໄດ້ຖືກເຮັດສໍາລັບພວກເຮົາໂດຍປະຊາຊົນຈາກ STM, ເຊິ່ງພວກເຮົາຂໍຂອບໃຈພວກເຂົາຫຼາຍ (ອີກເທື່ອຫນຶ່ງຂ້ອຍຈະໃຫ້ການເຊື່ອມຕໍ່ກັບ ເວັບໄຊທ໌ Di Halt, ເພື່ອເຮັດໃຫ້ມັນຊັດເຈນວ່າມັນສັບສົນ). ພວກ​ເຮົາ​ພຽງ​ແຕ່​ຕ້ອງ​ການ​ການ​ຈົດ​ທະ​ບຽນ​ທີ່​ມີ​ຄວາມ​ຮັບ​ຜິດ​ຊອບ​ສໍາ​ລັບ​ການ​ເປີດ​ໃຊ້​ງານ​ການ​ໂມງ​ຕໍ່​ຂ້າງ (Peripheral Clock Enable Registers). ທໍາອິດ, ໃຫ້ຊອກຫາທີ່ຢູ່ພື້ນຖານຂອງ RCC, ມັນແມ່ນຢູ່ໃນຈຸດເລີ່ມຕົ້ນຂອງ "ແຜນທີ່ຄວາມຈໍາ":

#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 volts, ຢ່າລືມເຊື່ອມຕໍ່ພື້ນຖານ.

STM8 PWM

PWM ໃນ STM8

ໃນເວລາທີ່ຂ້າພະເຈົ້າພຽງແຕ່ວາງແຜນບົດຄວາມນີ້, ຂ້າພະເຈົ້າໄດ້ຕັດສິນໃຈ, ເປັນຕົວຢ່າງ, ເພື່ອພະຍາຍາມປະຕິບັດຫນ້າທີ່ບາງຢ່າງຂອງຊິບທີ່ບໍ່ຄຸ້ນເຄີຍໂດຍໃຊ້ພຽງແຕ່ແຜ່ນຂໍ້ມູນ, ເພື່ອວ່າຂ້ອຍຈະບໍ່ສິ້ນສຸດດ້ວຍຜູ້ຜະລິດເກີບໂດຍບໍ່ມີເກີບ. STM8 ແມ່ນເຫມາະສົມສໍາລັບບົດບາດນີ້: ກ່ອນອື່ນ ໝົດ, ຂ້ອຍມີກະດານຈີນສອງຄູ່ກັບ STM8S103, ແລະອັນທີສອງ, ມັນບໍ່ແມ່ນຄວາມນິຍົມຫຼາຍ, ສະນັ້ນການລໍ້ລວງທີ່ຈະອ່ານແລະຊອກຫາວິທີແກ້ໄຂໃນອິນເຕີເນັດແມ່ນມາຈາກການຂາດວິທີແກ້ໄຂເຫຼົ່ານີ້.

chip ຍັງມີ ເອ​ກະ​ສານ​ຂໍ້​ມູນ​ и ຄູ່ມືອ້າງອີງ RM0016, ໃນຄັ້ງທໍາອິດມີ pinout ແລະລົງທະບຽນທີ່ຢູ່, ໃນທີສອງ - ທຸກສິ່ງທຸກຢ່າງອື່ນ. STM8 ຖືກຕັ້ງໂຄງການຢູ່ໃນ C ໃນ IDE ຂີ້ຮ້າຍ ST Visual ພັດທະນາ.

ໂມງ ແລະ 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:

ຊິບແມ່ນຂະຫນາດນ້ອຍ, ຫຼາຍຫນ້າທີ່ຖືກໂຈະຢູ່ໃນ pins ດຽວກັນ. ສິ່ງທີ່ຢູ່ໃນວົງເລັບສີ່ຫຼ່ຽມແມ່ນ "ການທໍາງານທາງເລືອກ", ມັນຖືກປ່ຽນໂດຍ "ທາງເລືອກ bytes" (ທາງເລືອກ bytes) - ບາງສິ່ງບາງຢ່າງເຊັ່ນ: Atmega fuses. ທ່ານ​ສາ​ມາດ​ປ່ຽນ​ແປງ​ຄຸນ​ຄ່າ​ຂອງ​ເຂົາ​ເຈົ້າ​ໂຄງ​ການ​, ແຕ່​ວ່າ​ມັນ​ບໍ່​ຈໍາ​ເປັນ​, ເພາະ​ວ່າ​ ຟັງຊັນໃຫມ່ແມ່ນເປີດໃຊ້ຫຼັງຈາກປິດເປີດໃຫມ່ເທົ່ານັ້ນ. ມັນງ່າຍກວ່າທີ່ຈະໃຊ້ ST Visual Programmer (ດາວໂຫຼດດ້ວຍ Visual Develop), ເຊິ່ງສາມາດປ່ຽນໄບທ໌ເຫຼົ່ານີ້ໄດ້. pinout ສະແດງໃຫ້ເຫັນວ່າ pins CH1 ແລະ CH2 ຂອງ timer ທໍາອິດຖືກເຊື່ອງໄວ້ໃນວົງເລັບສີ່ຫລ່ຽມ; ມັນເປັນສິ່ງຈໍາເປັນທີ່ຈະກໍານົດ AFR1 ແລະ AFR0 bits ໃນ 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 ກັບ chip ກັບ 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 - ຄ່າ autoloadable ສູງ​ເຖິງ​ທີ່ timer ຈະ​ນັບ (ໄລ​ຍະ​ກໍາ​ມະ​ຈອນ​)​;
• ອັບເດດເຫດການ, UEV – ເຫດການທີ່ເກີດຂຶ້ນເມື່ອໂມງຈັບເວລານັບເປັນ AR;
• ວົງຈອນຫນ້າທີ່ PWM – ຮອບວຽນໜ້າທີ່ຂອງ PWM, ມັກຈະເອີ້ນວ່າ “ປັດໄຈໜ້າທີ່”;
• ບັນທຶກ/ປຽບທຽບມູນຄ່າ - ມູນ​ຄ່າ​ສໍາ​ລັບ​ການ​ຈັບ​ພາບ / ການ​ປຽບ​ທຽບ​, ທີ່ timer ໄດ້​ນັບ​ ຈະເຮັດບາງສິ່ງບາງຢ່າງ (ໃນກໍລະນີຂອງ PWM, ມັນ inverts ສັນຍານຜົນຜະລິດ);
• ຄ່າລ່ວງໜ້າ - ຄ່າ preloaded. ປຽບທຽບມູນຄ່າ ບໍ່ສາມາດປ່ຽນແປງໄດ້ໃນຂະນະທີ່ເຄື່ອງຈັບເວລາຖືກໝາຍ, ຖ້າບໍ່ດັ່ງນັ້ນວົງຈອນ PWM ຈະແຕກ. ດັ່ງນັ້ນ, ມູນຄ່າການຖ່າຍທອດໃຫມ່ແມ່ນຖືກຈັດໃສ່ໃນ buffer ແລະດຶງອອກໃນເວລາທີ່ timer ມາຮອດໃນຕອນທ້າຍຂອງການນັບຖອຍຫລັງຂອງມັນແລະຖືກຕັ້ງຄ່າໃຫມ່;
• ຈັດຮຽງຂອບ и ໂໝດຈັດຮຽງກາງ - ການ​ຈັດ​ວາງ​ຕາມ​ຊາຍ​ແດນ​ແລະ​ຢູ່​ໃນ​ສູນ​ກາງ​, ເຊັ່ນ​ດຽວ​ກັນ​ກັບ Atmel ຂອງ​ PWM ໄວ и PWM ໄລຍະທີ່ຖືກຕ້ອງ.
• OciREF, ຜົນຜະລິດປຽບທຽບສັນຍານອ້າງອີງ - ສັນຍານຜົນຜະລິດອ້າງອີງ, ໃນຄວາມເປັນຈິງ, ສິ່ງທີ່ປາກົດຢູ່ໃນ pin ທີ່ສອດຄ້ອງກັນໃນຮູບແບບ 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 ທໍາອິດ screws ຂຶ້ນແລະຫຼັງຈາກນັ້ນປຽບທຽບ, ຜົນໄດ້ຮັບ compare value == 0 ຜົນຜະລິດແມ່ນເຂັມ, ເຊິ່ງຕ້ອງໄດ້ຮັບການຈັດການກັບ somehow (ຕົວຢ່າງ, ໂດຍ programmatically inverting ຕາມເຫດຜົນ).

ດັ່ງນັ້ນສິ່ງທີ່ພວກເຮົາຕ້ອງການເຮັດ: 8-bit PWM (AR == 255), ນັບຈາກລຸ່ມຫາເທິງ, ການຈັດລຽງຕາມຊາຍແດນ. ເນື່ອງຈາກຫລອດໄຟເຊື່ອມຕໍ່ກັບຊິບໂດຍ cathodes, PWM ຄວນອອກ 0 (LED ເປີດ) ຈົນກ່ວາ. ປຽບທຽບມູນຄ່າ ແລະ 1 ຫຼັງ.

ພວກເຮົາໄດ້ອ່ານແລ້ວກ່ຽວກັບບາງ ຮູບແບບ PWM, ດັ່ງນັ້ນພວກເຮົາຊອກຫາການລົງທະບຽນທີ່ຕ້ອງການຂອງ timer ທີສອງໂດຍການຄົ້ນຫາໃນຄູ່ມືການອ້າງອິງສໍາລັບປະໂຫຍກນີ້ (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 preload
0: Preload register on TIMx_CCR1 is disabled. ທ່ານສາມາດຂຽນໃສ່ TIMx_CCR1 ໄດ້ທຸກເວລາ. ມູນຄ່າໃຫມ່ເຮັດວຽກທັນທີ.
1: Preload register on TIMx_CCR1 is enabled. ການ​ດໍາ​ເນີນ​ງານ​ອ່ານ / ຂຽນ​ເຂົ້າ​ເຖິງ​ການ​ຈົດ​ທະ​ບຽນ preload ໄດ້​. ຄ່າ 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;

ທັງຫມົດທີ່ຍັງເຫຼືອແມ່ນເພື່ອເປີດການສະຫລຸບແລະຈັບເວລາທີສອງຂອງມັນເອງ. ບັນຫາທໍາອິດຖືກແກ້ໄຂໂດຍການລົງທະບຽນ ບັນທຶກ/ປຽບທຽບ ເປີດນໍາໃຊ້: ມີສອງ, ສາມຊ່ອງກະແຈກກະຈາຍໄປທົ່ວພວກມັນບໍ່ສົມມາດ. ໃນທີ່ນີ້ພວກເຮົາຍັງສາມາດຮຽນຮູ້ວ່າມັນເປັນໄປໄດ້ທີ່ຈະມີການປ່ຽນແປງ polarity ຂອງສັນຍານ, i.e. ໃນຫຼັກການ, ມັນເປັນໄປໄດ້ທີ່ຈະໃຊ້ PWM Mode 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(), ເຊິ່ງຈະໂອນຄ່າຕົວຈິງໃຫ້ກັບ timer ສຳລັບການປຽບທຽບ. ທະບຽນມີຊື່ທີ່ຄາດເດົາໄດ້ ບັນທຶກ/ປຽບທຽບການລົງທະບຽນ, ມີສອງອັນສໍາລັບແຕ່ລະຊ່ອງ: ຄໍາສັ່ງຕ່ໍາ 8 ບິດໃນ TIM2_CCRxL ແລະອັນທີ່ມີຄໍາສັ່ງສູງໃນ TIM2_CCRxH. ເນື່ອງຈາກພວກເຮົາໄດ້ສ້າງ PWM 8-bit, ມັນພຽງພໍທີ່ຈະຂຽນພຽງແຕ່ bits ຫນ້ອຍທີ່ສຸດ:

#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, ສັນຍານແມ່ນ inverted ສໍາລັບວົງຈອນ timer ຫນຶ່ງ). ສໍາລັບ LEDs ນີ້ບໍ່ສໍາຄັນ, ແລະຜູ້ອ່ານທີ່ເອົາໃຈໃສ່ສາມາດຄາດເດົາໄດ້ວ່າຈະແກ້ໄຂມັນໄດ້ແນວໃດ.

PWM ໃນເຄື່ອງຈັບເວລາທີສອງເຮັດວຽກ, ໃຫ້ເຮົາກ້າວໄປສູ່ຕົວທໍາອິດ.

ເຄື່ອງຈັບເວລາທໍາອິດມີບິດດຽວກັນຢູ່ໃນທະບຽນດຽວກັນ (ມັນພຽງແຕ່ວ່າບິດທີ່ຍັງຄົງ "ສະຫງວນ" ຢູ່ໃນເຄື່ອງຈັບເວລາທີສອງແມ່ນຖືກນໍາໃຊ້ຢ່າງຫ້າວຫັນໃນຄັ້ງທໍາອິດສໍາລັບທຸກປະເພດຂອງສິ່ງກ້າວຫນ້າ). ດັ່ງນັ້ນ, ມັນພຽງພໍທີ່ຈະຊອກຫາທີ່ຢູ່ຂອງທະບຽນດຽວກັນໃນເອກະສານຂໍ້ມູນແລະຄັດລອກລະຫັດ. ແລ້ວ, ປ່ຽນຄ່າຂອງຕົວແບ່ງຄວາມຖີ່, ເພາະວ່າ... ຕົວຈັບເວລາທໍາອິດຕ້ອງການທີ່ຈະໄດ້ຮັບບໍ່ແມ່ນພະລັງງານຂອງສອງ, ແຕ່ມູນຄ່າ 16-bit ທີ່ແນ່ນອນໃນສອງທະບຽນ Prescaler ສູງ и ຕ່ໍາ. ພວກເຮົາເຮັດທຸກສິ່ງທຸກຢ່າງແລະ ... timer ທໍາອິດບໍ່ໄດ້ເຮັດວຽກ. ແມ່ນຫຍັງ?

ບັນຫາສາມາດແກ້ໄຂໄດ້ໂດຍການເບິ່ງຜ່ານພາກສ່ວນທັງຫມົດກ່ຽວກັບບັນທຶກການຄວບຄຸມຂອງ timer 1, ບ່ອນທີ່ພວກເຮົາຊອກຫາຫນຶ່ງທີ່ timer ທີສອງບໍ່ມີ. ຈະ​ມີ 17.7.30 ລົງທະບຽນພັກຜ່ອນ (TIM1_BKR), ບ່ອນທີ່ມີ bit ນີ້:

ເປີດໃຊ້ຜົນຜະລິດຕົ້ນຕໍ

#define TIM1_BKR   *(volatile uint8_t *)0x00526D

TIM1_BKR = (1<<7);

ນັ້ນແມ່ນທັງຫມົດສໍາລັບແນ່ນອນໃນປັດຈຸບັນ, ລະຫັດ ຢູ່ທີ່ນັ້ນ.

STM8 Multiplex

Multiplexing ໃນ STM8

ໂຄງການ mini ທີສາມແມ່ນການເຊື່ອມຕໍ່ແປດ RGB LEDs ກັບເຄື່ອງຈັບເວລາທີສອງໃນໂຫມດ PWM ແລະເຮັດໃຫ້ພວກມັນສະແດງສີທີ່ແຕກຕ່າງກັນ. ມັນແມ່ນອີງໃສ່ແນວຄວາມຄິດຂອງ LED multiplexing, ເຊິ່ງແມ່ນວ່າຖ້າທ່ານເປີດແລະປິດ LEDs ຫຼາຍ, ໄວ, ມັນຈະເບິ່ງຄືວ່າພວກເຮົາຢູ່ຕະຫຼອດເວລາ (ຄວາມຄົງທົນຂອງວິໄສທັດ, inertia ຂອງການຮັບຮູ້ສາຍຕາ). ຂ້ອຍເຄີຍເຮັດ ບາງສິ່ງບາງຢ່າງເຊັ່ນນີ້ໃນ Arduino.

ຂັ້ນຕອນການເຮັດວຽກເບິ່ງຄືວ່າ:

• ເຊື່ອມຕໍ່ anode ຂອງ RGB LED ທໍາອິດ;
• lit ມັນ, ສົ່ງສັນຍານທີ່ຈໍາເປັນກັບ cathodes;
• ລໍຖ້າຈົນກ່ວາໃນຕອນທ້າຍຂອງວົງຈອນ PWM;
• ເຊື່ອມຕໍ່ anode ຂອງ LED RGB ທີສອງ;
• ຈູດມັນ...

ດີ, ແລະອື່ນໆ. ແນ່ນອນ, ສໍາລັບການດໍາເນີນງານທີ່ສວຍງາມ, ມັນຈໍາເປັນຕ້ອງເຊື່ອມຕໍ່ anode ແລະ LED ແມ່ນ "ໄຟ" ໃນເວລາດຽວກັນ. ດີ, ຫຼືເກືອບ. ໃນກໍລະນີໃດກໍ່ຕາມ, ພວກເຮົາຈໍາເປັນຕ້ອງຂຽນລະຫັດທີ່ຈະສົ່ງຄ່າໃນສາມຊ່ອງທາງຂອງເຄື່ອງຈັບເວລາທີສອງ, ປ່ຽນພວກມັນເມື່ອ UEV ມາຮອດ, ແລະໃນເວລາດຽວກັນປ່ຽນ RGB LED ທີ່ໃຊ້ໃນປັດຈຸບັນ.

ເນື່ອງຈາກການສະຫຼັບ LED ແມ່ນອັດຕະໂນມັດ, ພວກເຮົາຈໍາເປັນຕ້ອງສ້າງ "ຫນ່ວຍຄວາມຈໍາວິດີໂອ" ທີ່ຕົວຈັດການຂັດຂວາງຈະໄດ້ຮັບຂໍ້ມູນ. ນີ້ແມ່ນ array ງ່າຍດາຍ:

uint8_t colors[8][3];

ເພື່ອປ່ຽນສີຂອງ LED ສະເພາະ, ມັນຈະພຽງພໍທີ່ຈະຂຽນຄ່າທີ່ຕ້ອງການເຂົ້າໄປໃນ array ນີ້. ແລະຕົວແປຈະຮັບຜິດຊອບຕໍ່ຈໍານວນຂອງ LED ທີ່ມີການເຄື່ອນໄຫວ

uint8_t cnt;

Demux

ສໍາລັບການ multiplexing ທີ່ເຫມາະສົມ, ພວກເຮົາຕ້ອງການ, oddly ພຽງພໍ, CD74HC238 demultiplexer. Demultiplexer - ຊິບທີ່ປະຕິບັດຕົວປະຕິບັດການໃນຮາດແວ <<. ໂດຍຜ່ານສາມ pins input (bits 0, 1 ແລະ 2) ພວກເຮົາໃຫ້ອາຫານມັນຈໍານວນສາມບິດ X, ແລະໃນການຕອບສະຫນອງມັນເປີດໃຊ້ຈໍານວນຜົນຜະລິດ (1<<X). ວັດສະດຸປ້ອນທີ່ຍັງເຫຼືອຂອງຊິບແມ່ນໃຊ້ເພື່ອປັບຂະໜາດການອອກແບບທັງໝົດ. ພວກເຮົາຕ້ອງການຊິບນີ້ບໍ່ພຽງແຕ່ຫຼຸດຜ່ອນຈໍານວນຂອງ pins ຄອບຄອງຂອງ microcontroller ໄດ້, ແຕ່ຍັງຄວາມປອດໄພ - ເພື່ອບໍ່ໃຫ້ອຸບັດຕິເຫດເປີດໄຟ LEDs ຫຼາຍກ່ວາທີ່ເປັນໄປໄດ້ແລະບໍ່ໄຫມ້ MK ໄດ້. ຊິບມີລາຄາເປັນເງິນ ແລະຄວນເກັບຮັກສາໄວ້ໃນຕູ້ຢາຢູ່ເຮືອນຂອງທ່ານສະເໝີ.

CD74HC238 ຂອງພວກເຮົາຈະຮັບຜິດຊອບໃນການສະຫນອງແຮງດັນໃຫ້ anode ຂອງ LED ທີ່ຕ້ອງການ. ໃນ multiplex ເຕັມຮູບແບບ, ມັນຈະສະຫນອງແຮງດັນໃຫ້ຖັນຜ່ານ P-MOSFET, ແຕ່ໃນຕົວຢ່າງນີ້ມັນເປັນໄປໄດ້ໂດຍກົງ, ເພາະວ່າ. ມັນແຕ້ມ 20 mA, ອີງຕາມ ຄະແນນສູງສຸດຢ່າງແທ້ຈິງ ຢູ່ໃນແຜ່ນຂໍ້ມູນ. ຈາກ ແຜ່ນຂໍ້ມູນ CD74HC238 ພວກເຮົາຕ້ອງການ pinouts ແລະແຜ່ນ cheat ນີ້:

H = ລະດັບແຮງດັນສູງ, L = ລະດັບແຮງດັນຕໍ່າ, X – ບໍ່ສົນໃຈ

ພວກເຮົາເຊື່ອມຕໍ່ E2 ແລະ E1 ກັບດິນ, E3, A0, A1 ແລະ A3 ກັບ pins PD5, PC3, PC4 ແລະ PC5 ຂອງ STM8. ເນື່ອງຈາກຕາຕະລາງຂ້າງເທິງມີທັງລະດັບຕໍ່າ ແລະລະດັບສູງ, ພວກເຮົາກຳນົດຄ່າ pins ເຫຼົ່ານີ້ເປັນ pins push-pull.

PWM

PWM ໃນເຄື່ອງຈັບເວລາທີສອງຖືກຕັ້ງຄ່າໃນລັກສະນະດຽວກັນກັບເລື່ອງທີ່ຜ່ານມາ, ມີສອງຄວາມແຕກຕ່າງ:

ກ່ອນອື່ນ ໝົດ, ພວກເຮົາ ຈຳ ເປັນຕ້ອງເປີດໃຊ້ການຂັດຂວາງ ອັບເດດເຫດການ (UEV) ເຊິ່ງຈະເອີ້ນຟັງຊັນທີ່ສະຫຼັບ LED ທີ່ໃຊ້ວຽກ. ນີ້ແມ່ນເຮັດໄດ້ໂດຍການປ່ຽນບິດ ອັບເດດ Interrupt ເປີດໃຊ້ງານ ໃນທະບຽນທີ່ມີຊື່ບອກ

ຂັດຂວາງການລົງທະບຽນ

#define TIM2_IER   *(volatile uint8_t *)0x005303

//enable interrupt
TIM2_IER = 1;

ຄວາມແຕກຕ່າງທີ່ສອງແມ່ນກ່ຽວຂ້ອງກັບປະກົດການ multiplexing, ເຊັ່ນ: ຜີ - ກາຝາກຂອງ diodes. ໃນກໍລະນີຂອງພວກເຮົາ, ມັນອາດຈະປາກົດຍ້ອນຄວາມຈິງທີ່ວ່າເຄື່ອງຈັບເວລາ, ເຮັດໃຫ້ເກີດການຂັດຂວາງໃນ UEV, ສືບຕໍ່ຫມາຍຕິກ, ແລະຕົວຈັບຂັດຂວາງບໍ່ມີເວລາທີ່ຈະປ່ຽນໄຟ LED ກ່ອນທີ່ເຄື່ອງຈັບເວລາເລີ່ມຕົ້ນຂຽນບາງສິ່ງບາງຢ່າງໃສ່ pins. ເພື່ອຕ້ານການນີ້, ທ່ານຈະຕ້ອງ invert ຕາມເຫດຜົນ (0 = ຄວາມສະຫວ່າງສູງສຸດ, 255 = ບໍ່ມີຫຍັງເປັນໄຟ) ແລະຫຼີກເວັ້ນການຄ່າວົງຈອນຫນ້າທີ່ຮ້າຍແຮງ. ເຫຼົ່ານັ້ນ. ໃຫ້ແນ່ໃຈວ່າຫຼັງຈາກ UEV, LEDs ອອກໄປຫມົດສໍາລັບວົງຈອນ PWM.

ການ​ປ່ຽນ​ແປງ Polarity​:

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

ຫຼີກເວັ້ນການຕັ້ງ r, g ແລະ b ເປັນ 255 ແລະຈື່ຈໍາທີ່ຈະປ່ຽນພວກມັນເມື່ອໃຊ້ພວກມັນ.

ຂັດຂວາງ

ໂດຍເນື້ອແທ້ແລ້ວຂອງການຂັດຂວາງແມ່ນວ່າພາຍໃຕ້ສະຖານະການສະເພາະໃດຫນຶ່ງ chip ຢຸດເຊົາການດໍາເນີນການໂຄງການຕົ້ນຕໍແລະໂທຫາບາງຫນ້າທີ່ພາຍນອກ. ການຂັດຂວາງເກີດຂື້ນຍ້ອນອິດທິພົນພາຍນອກຫຼືພາຍໃນ, ລວມທັງຕົວຈັບເວລາ.

ເມື່ອພວກເຮົາສ້າງໂຄງການທໍາອິດໃນ ST Visual Develop, ນອກເຫນືອຈາກ main.c ພວກເຮົາໄດ້ຮັບປ່ອງຢ້ຽມທີ່ມີໄຟລ໌ລຶກລັບ stm8_interrupt_vector.c, ອັດຕະໂນມັດລວມຢູ່ໃນໂຄງການ. ໃນໄຟລ໌ນີ້, ຫນ້າທີ່ຖືກມອບຫມາຍໃຫ້ແຕ່ລະຂັດຂວາງ NonHandledInterrupt. ພວກເຮົາຈໍາເປັນຕ້ອງໄດ້ຜູກມັດຫນ້າທີ່ຂອງພວກເຮົາກັບການຂັດຂວາງທີ່ຕ້ອງການ.

ແຜ່ນຂໍ້ມູນມີຕາຕະລາງຂອງ vectors ຂັດຂວາງ, ບ່ອນທີ່ພວກເຮົາຊອກຫາອັນທີ່ພວກເຮົາຕ້ອງການ:

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