Arduino ಟೈಮರ್: ನಿಮ್ಮ ಯೋಜನೆಗಳಲ್ಲಿ ಸಮಯದೊಂದಿಗೆ ಪ್ಲೇ ಮಾಡಿ

ಕೆಲವು ಸಮಯದ ಹಿಂದೆ ನಾವು ಅದರ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ಮಾಹಿತಿಯನ್ನು ಪ್ರಕಟಿಸಿದ್ದೇವೆ ಮಿಲಿಸ್() ಕಾರ್ಯ de ಆರ್ಡುನೋಈಗ ನಾವು ಆಳವಾಗಿ ಪರಿಶೀಲಿಸುತ್ತೇವೆ ಆರ್ಡುನೊ ಟೈಮರ್, ವೈಶಿಷ್ಟ್ಯಕ್ಕಾಗಿ ಈ ವೈಶಿಷ್ಟ್ಯದೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲು, ಈ ಬೋರ್ಡ್ MCU ನೊಂದಿಗೆ ಸಮಯವನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ, ಹಾಗೆಯೇ millis() ಅನ್ನು ಮೀರಿದ ಇತರ ಕಾರ್ಯಗಳನ್ನು.

Arduino ಟೈಮರ್ ಎಂದರೇನು?

El ಆರ್ಡುನೊ ಟೈಮರ್, ಅಥವಾ ಟೈಮರ್, ಇದು ಹಾರ್ಡ್‌ವೇರ್‌ನಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ ಕಾರ್ಯವಾಗಿದೆ (ಮೈಕ್ರೋಕಂಟ್ರೋಲರ್‌ನಲ್ಲಿ, ಗಡಿಯಾರ ನಾಡಿಗಳನ್ನು ಉತ್ಪಾದಿಸುವ ಕ್ವಾರ್ಟ್ಜ್ ಸ್ಫಟಿಕದ ಸಹಾಯದಿಂದ ಮತ್ತು ಬಾಹ್ಯ ಹಾರ್ಡ್‌ವೇರ್ ಅಥವಾ IC ಗಳು 555 ಅಗತ್ಯವಿಲ್ಲದೇ "ರಿದಮ್" ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ) ಇದು ಗಡಿಯಾರಗಳಿಗೆ ಧನ್ಯವಾದಗಳು ತಾತ್ಕಾಲಿಕ ಘಟನೆಗಳನ್ನು ನಿಯಂತ್ರಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಆಂತರಿಕ. ಉದಾಹರಣೆಗೆ, ಸ್ಕೆಚ್ ಕೋಡ್‌ನಿಂದ ಸ್ವತಂತ್ರವಾಗಿ ಕಾರ್ಯವನ್ನು ಮಧ್ಯಂತರದಲ್ಲಿ ಸಂಭವಿಸುವಂತೆ ಮಾಡುವುದು, ನಿಖರವಾದ ಸಮಯದ ಅಳತೆಗಳನ್ನು ಮಾಡುವುದು ಇತ್ಯಾದಿ.

ನೀವು ಬಳಸುತ್ತೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ ವಿಳಂಬ () ಕಾರ್ಯ, ಇದು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸಮಯ ಮುಗಿಯುವವರೆಗೆ Arduino MCU ನಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಪ್ರೋಗ್ರಾಂನೊಂದಿಗೆ ಮುಂದುವರಿಯುತ್ತದೆ, ಆದರೆ ಟೈಮರ್ ನಿರ್ಬಂಧಿಸುವುದಿಲ್ಲ. MCU ಇತರ ಸೂಚನೆಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ಮುಂದುವರಿಸುವುದರಿಂದ ಇದು ಸಮಯವಾಗಿರುತ್ತದೆ. ಅದೇ ದೊಡ್ಡ ಅನುಕೂಲ.

ಟೈಮರ್ ಸಂಬಂಧಿಸಿದೆ ಅಡಚಣೆಗಳು Arduino ನ, ಕೆಲವು ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಕ್ಕೆ ಹಾಜರಾಗಲು ಅವರ ಮೂಲಕ ಅವುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, Arduino ಟೈಮರ್ ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಮಯದಲ್ಲಿ ಪ್ರಚೋದಿಸಲ್ಪಟ್ಟ ಒಂದು ಕಾರ್ಯವಾಗಿದೆ, ಇದು ಅಡಚಣೆ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಅದಕ್ಕಾಗಿಯೇ ಈ ಅಡಚಣೆಗಳ ಬಗ್ಗೆ ತಿಳಿದುಕೊಳ್ಳುವುದು ಸಹ ಮುಖ್ಯವಾಗಿದೆ.

ಮೋಡ್‌ಗಳು

Arduino ಟೈಮರ್ ಹೊಂದಿದೆ 2 ಆಪರೇಟಿಂಗ್ ಮೋಡ್‌ಗಳು, ಇದನ್ನು ಬಳಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ:

• PWM ಸಿಗ್ನಲ್: ನೀವು ನಿಯಂತ್ರಿಸಬಹುದು ಆರ್ಡುನೊ ಪಿನ್‌ಗಳು (~).
• CTC (ಹೋಲಿಕೆಯಲ್ಲಿ ಟೈಮರ್ ಅನ್ನು ತೆರವುಗೊಳಿಸಿ): ಕೌಂಟರ್ ಒಳಗೆ ಸಮಯವನ್ನು ಎಣಿಸುತ್ತದೆ ಮತ್ತು ಟೈಮರ್‌ಗಳ ರಿಜಿಸ್ಟರ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಮೌಲ್ಯವನ್ನು ಅದು ತಲುಪಿದಾಗ, ಅಡಚಣೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ಇದು ಎಷ್ಟು ಟೈಮರ್‌ಗಳನ್ನು ಹೊಂದಿದೆ? ಟೈಮರ್‌ಗಳ ವಿಧಗಳು

ಇವೆ 3 ಟೈಮರ್‌ಗಳು ಫಲಕಗಳ ಮೇಲೆ Arduino UNO, ಇತರ ಟಾಪ್ ಪ್ಲೇಟ್‌ಗಳಲ್ಲಿ ಹೆಚ್ಚು ಇರಬಹುದು:

• ಟೈಮರ್ 0: 8-ಬಿಟ್, 0 ರಿಂದ 255 ವರೆಗೆ ಎಣಿಸಬಹುದು (256 ಸಂಭವನೀಯ ಮೌಲ್ಯಗಳು). ವಿಳಂಬ(), ಮಿಲಿಸ್(), ಮತ್ತು ಮೈಕ್ರೋಸ್() ನಂತಹ ಕಾರ್ಯಗಳಿಂದ ಬಳಸಲಾಗಿದೆ. ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಬದಲಾಯಿಸದಂತೆ ಅದರ ಮಾರ್ಪಾಡು ಶಿಫಾರಸು ಮಾಡಲಾಗಿಲ್ಲ.
• ಟೈಮರ್ 1: ಟೈಮರ್ 0 ಗೆ ಸಮ. UNO ನಲ್ಲಿ ಸರ್ವೋ ಲೈಬ್ರರಿಯಿಂದ ಬಳಸಲಾಗಿದೆ (MEGA ಗಾಗಿ ಟೈಮರ್ 5).
• ಟೈಮರ್ 2: 16-ಬಿಟ್, ಮತ್ತು 0 ರಿಂದ 65.525 (65.536 ಸಂಭವನೀಯ ಮೌಲ್ಯಗಳು) ವ್ಯಾಪ್ತಿಯಲ್ಲಿರಬಹುದು. ಟೋನ್() ಕಾರ್ಯಕ್ಕಾಗಿ ಬಳಸಲಾಗಿದೆ, ಬಳಸದಿದ್ದರೆ, ಅದನ್ನು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಮುಕ್ತವಾಗಿ ಬಳಸಬಹುದು.
• ಟೈಮರ್ 3, 4, 5 (ಆರ್ಡುನೊ ಮೆಗಾದಲ್ಲಿ ಮಾತ್ರ): ಎಲ್ಲಾ 16-ಬಿಟ್.

Arduino ಟೈಮರ್ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ?

ಸಾಧ್ಯವಾಗುತ್ತದೆ Arduino ಟೈಮರ್ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿ, ಈ ಅಭಿವೃದ್ಧಿ ಮಂಡಳಿಯ MCU ನಲ್ಲಿ ಇದೆಲ್ಲವೂ ವಿದ್ಯುನ್ಮಾನವಾಗಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ:

• ಗಡಿಯಾರ ಆವರ್ತನ: ಇದು ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಸಾಮರ್ಥ್ಯವಿರುವ ಚಕ್ರಗಳ ಸಂಖ್ಯೆ, ಆರ್ಡುನೊ ಸಂದರ್ಭದಲ್ಲಿ ಅದು 16 Mhz ಆಗಿದೆ, ಅಥವಾ ಅದೇ ರೀತಿ, ಗಡಿಯಾರ ಸಂಕೇತವು ಸೆಕೆಂಡಿನಲ್ಲಿ 16.000.000 ಬಾರಿ ಆಂದೋಲನಗೊಳ್ಳುತ್ತದೆ (ಚಕ್ರಗಳು).
• ಅವಧಿ: T ನಿಂದ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಅಳೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಚಕ್ರಗಳ ವಿಲೋಮವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, T=1/C, ಇದು 1/16000000 = 0.0000000625 ಗೆ ಕಾರಣವಾಗುತ್ತದೆ, ಪ್ರತಿ ಚಕ್ರವು ಪೂರ್ಣಗೊಳ್ಳಲು ತೆಗೆದುಕೊಳ್ಳುವ ಸಮಯ. ಮತ್ತು ಆವರ್ತನವು ಅವಧಿಯ ವಿಲೋಮವಾಗಿದೆ, ಆದ್ದರಿಂದ f = 1/T.
• ಸೈಕಲ್: ಯುನಿಟ್ ಸಮಯದ ಪ್ರತಿ ಸಂಭವಿಸುವ ಸಂಕೇತದ ಪುನರಾವರ್ತನೆಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದೂ ಒಂದಾಗಿದೆ. Arduino ನಲ್ಲಿ ಇದು ಒಂದು ಸೆಕೆಂಡಿನಲ್ಲಿ 16M ಆಗಿರುತ್ತದೆ. ಅಥವಾ ಅದೇ ಏನು, ಈ ಸಂದರ್ಭದಲ್ಲಿ, 16 ಮಿಲಿಯನ್ ಚಕ್ರಗಳು ಕಳೆದಾಗ, ಒಂದು ಸೆಕೆಂಡ್ ಕಳೆದಿದೆ. ಆದ್ದರಿಂದ, ಒಂದು ಚಕ್ರವು 625 ಎನ್ಎಸ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಎಂದು ಹೇಳಬಹುದು.
• ಸಂಕೇತದ ಅಂಚು: ಗಡಿಯಾರದ ಸಂಕೇತಗಳು ಚೌಕಾಕಾರವಾಗಿರುತ್ತವೆ ಮತ್ತು ಅಂಚುಗಳು ಏರಬಹುದು ಅಥವಾ ಬೀಳಬಹುದು. ಒಂದು ಅಂಚು ಸಿಗ್ನಲ್‌ನ ನೇರ ರೇಖೆಯಾಗಿದ್ದು ಅದು ಬದಲಾದಾಗ:
  • 0 (ಕಡಿಮೆ) ರಿಂದ 1 (ಹೆಚ್ಚು): ಏರುತ್ತಿರುವ ಅಂಚು.
  • 1 (ಹೆಚ್ಚಿನ) ರಿಂದ 0 (ಕಡಿಮೆ): ಬೀಳುವ ಅಂಚು.

ಆರ್ಡುನೊ ಟೈಮರ್‌ಗಳು ಸಿಗ್ನಲ್ ಅಂಚುಗಳಿಂದ ಚಕ್ರಗಳನ್ನು ಅಳೆಯುವ ಕಾರಣ ಅಂಚುಗಳು ಮುಖ್ಯವಾಗಿವೆ. ಎ) ಹೌದು ಎಲ್ contador ಇದು ಪ್ರತಿ ಚಕ್ರದೊಂದಿಗೆ ಹೆಚ್ಚಾಗುತ್ತದೆ ಮತ್ತು ಅದು ರಿಜಿಸ್ಟರ್ ಮೌಲ್ಯವನ್ನು ತಲುಪಿದಾಗ, ಅಡಚಣೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ಆದ್ದರಿಂದ, ಒಮ್ಮೆ ನೀವು ಇದನ್ನು ತಿಳಿದಿದ್ದರೆ, ನೀವು ಹೊಂದಿದ್ದರೆ Arduino MCU ನಲ್ಲಿ 16Mhz, ಮತ್ತು 8-ಬಿಟ್ ಟೈಮರ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಪ್ರತಿ 16 μs (256/16000000) ಅಥವಾ 4 ms 16-ಬಿಟ್ (65536/16000000) ಗೆ ಅಡಚಣೆಗಳು ಸಂಭವಿಸುತ್ತವೆ ಎಂದು ಹೇಳಬಹುದು. ಆದ್ದರಿಂದ, ನೀವು 16 ಮೌಲ್ಯದೊಂದಿಗೆ 65535-ಬಿಟ್ ಕೌಂಟರ್ ರಿಜಿಸ್ಟರ್ ಅನ್ನು ಗರಿಷ್ಠಕ್ಕೆ ಹೊಂದಿಸಿದರೆ, ಯಾವುದೇ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು 4 ms ನಲ್ಲಿ ಅಡಚಣೆ ಉಂಟಾಗುತ್ತದೆ.

ಕೌಂಟರ್ ಗರಿಷ್ಠ ಸಂಭವನೀಯ ಮೌಲ್ಯವನ್ನು ತಲುಪಿದಾಗ, ಅದು ಮತ್ತೆ 0 ಗೆ ಹಿಂತಿರುಗುತ್ತದೆ. ಅಂದರೆ, ಉಕ್ಕಿ ಹರಿಯುತ್ತದೆ ಮತ್ತು ಅದು ಮೊದಲಿನಿಂದಲೂ ಎಣಿಕೆಯಾಗುತ್ತದೆ.

ಟೈಮರ್ನ ಹೆಚ್ಚಳದ ದರವನ್ನು ನಿಯಂತ್ರಿಸಲು ನೀವು ಸಹ ಬಳಸಬಹುದು ಒಂದು ಪ್ರಿಸ್ಕೇಲರ್, ಇದು 1, 8, 64, 256 ಮತ್ತು 1024 ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಈ ರೀತಿಯ ಸಮಯವನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ:

ಟೈಮರ್ ಸ್ಪೀಡ್ (Hz) = ಆರ್ಡುನೊ / ಪ್ರಿಸ್ಕೇಲರ್‌ನ ಗಡಿಯಾರ ಆವರ್ತನ

ಇದು 1 ಪ್ರಿಸ್ಕೇಲರ್ ಆಗಿದ್ದರೆ ನಿಯಂತ್ರಕವು 16 Mhz ಗೆ ಹೆಚ್ಚಾಗುತ್ತದೆ, ಅದು 8 ರಿಂದ 2 Mhz ಆಗಿದ್ದರೆ, ಅದು 64 ರಿಂದ 250 kHz ಆಗಿದ್ದರೆ, ಇತ್ಯಾದಿ. ಕೌಂಟರ್ ಮತ್ತು ಪ್ರಿಸ್ಕೇಲರ್‌ನ ಮೌಲ್ಯವನ್ನು ಸಮನಾಗುವವರೆಗೆ ಹೋಲಿಸಲು ಟೈಮರ್ ಕೌಂಟರ್ ಸ್ಟೇಟ್ ಹೋಲಿಕೆದಾರರು ಇರುತ್ತಾರೆ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ ಮತ್ತು ನಂತರ ಕ್ರಿಯೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ. ಆದ್ದರಿಂದ, ಅಡಚಣೆ ಆವರ್ತನ ಸೂತ್ರದಿಂದ ನೀಡಲಾಗಿದೆ:

ಇಂಟರಪ್ಟ್ ಸ್ಪೀಡ್ (Hz) = Arduino / Prescaler Clock Frequency (comparator Register value + 1)

ಅದೃಷ್ಟವಶಾತ್, ನಾವು ಮಾಡಬಾರದು ದಾಖಲೆಗಳನ್ನು ಮಾರ್ಪಡಿಸಿ Arduino ಟೈಮರ್‌ಗಳು, ಏಕೆಂದರೆ ನಾವು ಕೋಡ್‌ನಲ್ಲಿ ಬಳಸುವ ಲೈಬ್ರರಿಗಳು ಇದನ್ನು ನೋಡಿಕೊಳ್ಳುತ್ತವೆ. ಆದರೆ ಅವುಗಳನ್ನು ಬಳಸದಿದ್ದರೆ, ಅವುಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕು.

Arduino IDE ನಲ್ಲಿನ ಉದಾಹರಣೆಗಳು

ಇದೆಲ್ಲವನ್ನೂ ಸ್ವಲ್ಪ ಚೆನ್ನಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಇಲ್ಲಿ ನಾನು Arduino IDE ಗಾಗಿ ಎರಡು ಸ್ಕೆಚ್ ಕೋಡ್‌ಗಳನ್ನು ತೋರಿಸುತ್ತೇನೆ ಅದರೊಂದಿಗೆ ನೀವು ಟೈಮರ್‌ಗಳ ಬಳಕೆಯನ್ನು ಅನುಭವಿಸಬಹುದು. ಮೊದಲನೆಯದು ಆರ್ಡುನೊ ಪಿನ್ 8 ಗೆ ಸಂಪರ್ಕಗೊಂಡಿರುವ ಎಲ್ಇಡಿಯನ್ನು ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ ಬ್ಲಿಂಕ್ ಮಾಡುವ ಕೋಡ್ ಆಗಿದೆ:

#define ledPin 8
void setup()
{
  pinMode(ledPin, OUTPUT);
  // Configurar Timer1
  TCCR1A = 0;                        //Registro control A a 0, pines OC1A y OC1B deshabilitados
  TCCR1B = 0;                        //Limpia el registrador
  TCCR1B |= (1<<CS10)|(1 << CS12);   //Configura prescaler a 1024: CS12 = 1 y CS10 = 1
  TCNT1 = 0xC2F8;                    //Iniciar timer para desbordamiento a 1 segundo
                                     //65536-(16MHz/1024/1Hz - 1) = 49912 = 0xC2F8 en hexadecimal
  
  TIMSK1 |= (1 << TOIE1);           //Habilitar interrupción para Timer1
}
void loop()
{
}
ISR(TIMER1_OVF_vect)                              //Interrupción del TIMER1 
{
  TCNT1 = 0xC2F7;                                 // Reniciar Timer1
  digitalWrite(ledPin, digitalRead(ledPin) ^ 1); //Invierte el estado del LED
}

ಹಿಂದಿನ ಸಂದರ್ಭದಲ್ಲಿ ಪ್ರತಿ ಸೆಕೆಂಡಿನಂತೆ ಎಲ್ಇಡಿ ಮಿಟುಕಿಸುವುದು ಅಥವಾ ಮಿನುಗುವಿಕೆಯನ್ನು ಪ್ರೋಗ್ರಾಂ ಮಾಡಿ, ಆದರೆ ಈ ಬಾರಿ ಬಳಸಿ CTC ಅಂದರೆ ಹೋಲಿಕೆ:

#define ledPin 8
void setup()
{
  pinMode(ledPin, OUTPUT);
  
  // Configuración Timer1
  TCCR1A = 0;                //Registro de control A a 0
  TCCR1B = 0;                //Limpiar registro
  TCNT1  = 0;                //Inicializar el temporizador
  OCR1A = 0x3D08;            //Carga el valor del registro de comparación: 16MHz/1024/1Hz -1 = 15624 = 0X3D08
  TCCR1B |= (1 << WGM12)|(1<<CS10)|(1 << CS12);   //Modo CTC, prescaler de 1024: CS12 = 1 y CS10 = 1  
  TIMSK1 |= (1 << OCIE1A);  //Habilita interrupción por igualdad de comparación
}
void loop()
{
}
ISR(TIMER1_COMPA_vect)          //Interrupción por igualdad de comparación en TIMER1
{
  digitalWrite(ledPin, digitalRead(ledPin) ^ 1);   //Invierte el estado del LED
}

Arduino ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು