ಕಡಿಮೆ ಪಾಸ್ ಫಿಲ್ಟರ್: ಈ ಸರ್ಕ್ಯೂಟ್ ಬಗ್ಗೆ ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಎಲ್ಲವೂ

ಸುರುಳಿಗಳು ಮತ್ತು ಆಪ್ ಆಂಪ್ಸ್ ಪ್ರಸಿದ್ಧವಾದಂತಹ ಕುತೂಹಲಕಾರಿ ಸರ್ಕ್ಯೂಟ್‌ಗಳನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ ಆವರ್ತನ ಫಿಲ್ಟರ್‌ಗಳು. ಈ ಫಿಲ್ಟರ್‌ಗಳು ಎಲೆಕ್ಟ್ರಾನಿಕ್ಸ್ ಉದ್ಯಮದಲ್ಲಿ ಬಹುಸಂಖ್ಯೆಯ ಅನ್ವಯಿಕೆಗಳನ್ನು ಹೊಂದಿವೆ. ಕಡಿಮೆ ಪಾಸ್ ಫಿಲ್ಟರ್, ಹೈ ಪಾಸ್ ಫಿಲ್ಟರ್ ಇತ್ಯಾದಿಗಳಂತೆಯೇ. ಕೆಲವು ಧ್ವನಿ ಅನ್ವಯಿಕೆಗಳಿಗೆ ಅವು ವಿಶೇಷವಾಗಿ ಆಸಕ್ತಿದಾಯಕವಾಗಿವೆ, ಶಬ್ದಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಅಥವಾ ಅವುಗಳ ಆವರ್ತನಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಹೆಚ್ಚು ಅಥವಾ ಕಡಿಮೆ ಗಂಭೀರ ಶಬ್ದಗಳು. ಆದ್ದರಿಂದ, ಅವು ತುಂಬಾ ಉಪಯುಕ್ತವಾಗಿವೆ.

ನೀವು ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳಲು ಬಯಸಿದರೆ ಕಡಿಮೆ ಪಾಸ್ ಫಿಲ್ಟರ್, ಮತ್ತು ಇತರ ಫಿಲ್ಟರ್‌ಗಳು, ಮತ್ತು ಆರ್ಡುನೊ ಅಥವಾ DIY ಯೊಂದಿಗಿನ ನಿಮ್ಮ ಯೋಜನೆಗಳಲ್ಲಿ ಅವು ನಿಮಗೆ ಹೇಗೆ ಸಹಾಯ ಮಾಡುತ್ತವೆ, ಓದುವುದನ್ನು ಮುಂದುವರಿಸಲು ನಾನು ನಿಮ್ಮನ್ನು ಪ್ರೋತ್ಸಾಹಿಸುತ್ತೇನೆ ...

ವಿದ್ಯುತ್ ಫಿಲ್ಟರ್‌ಗಳು

ಅದರ ಹೆಸರೇ ಸೂಚಿಸುವಂತೆ, ಫಿಲ್ಟರ್ ಎನ್ನುವುದು ಸರ್ಕ್ಯೂಟ್ ಆಗಿದ್ದು ಅದು ಸರಣಿ ಸುರುಳಿಗಳು ಮತ್ತು ಕೆಪಾಸಿಟರ್‌ಗಳಿಂದ ಕೂಡಿದೆ, ಮತ್ತು ಕೆಲವು ಕಾರ್ಯಾಚರಣಾ ಆಂಪ್ಲಿಫೈಯರ್‌ಗಳು ಸಹ ಇದರ ಉದ್ದೇಶಕ್ಕಾಗಿ ಆವರ್ತನದ ಕೆಲವು ಭಾಗಗಳನ್ನು ಮಾತ್ರ ಹಾದುಹೋಗಲು ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತದೆ. ಅಂದರೆ, ಲಭ್ಯವಿರುವ ಆವರ್ತನಗಳ ಸಂಪೂರ್ಣ ವರ್ಣಪಟಲದಲ್ಲಿ, ಅವುಗಳು ಹಾದುಹೋಗದಂತೆ ತಡೆಯಲು ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಭಾಗಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುತ್ತದೆ.

ಹೌದು ejemplo ನಾವು ಮನುಷ್ಯರಿಂದ ಕೇಳಬಹುದಾದ ಸ್ಪೆಕ್ಟ್ರಮ್ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ, ಅದು 20 Hz ನಿಂದ 20 Khz ಗೆ ಹೋಗುತ್ತದೆ, ಫಿಲ್ಟರ್‌ಗಳೊಂದಿಗೆ ನೀವು ಹೆಚ್ಚು ಅಥವಾ ಕಡಿಮೆ ತ್ರಿವಳಿ / ಬಾಸ್ ಶಬ್ದಗಳನ್ನು ಮಾತ್ರ ಹಾದುಹೋಗಲು ಅನುಮತಿಸುವ ಸಲುವಾಗಿ ಕಡಿಮೆ ಅಥವಾ ಹೆಚ್ಚಿನದನ್ನು ತೆಗೆದುಹಾಕಬಹುದು. ಇದು ಮೈಕ್ರೊಫೋನ್ಗಳು, ಸ್ಪೀಕರ್ಗಳು ಮುಂತಾದ ಅನೇಕ ಆಡಿಯೊ ರೆಕಾರ್ಡಿಂಗ್ ಅಥವಾ ಸಂತಾನೋತ್ಪತ್ತಿ ವ್ಯವಸ್ಥೆಗಳು ಬಳಸುವ ವಿಷಯ.

ವಿಧಗಳು

ಪ್ರಕಾರ ಫಿಲ್ಟರ್ ಪ್ರಕಾರ, ಅಥವಾ ಬದಲಿಗೆ, ಅವರು ನಿರ್ಬಂಧಿಸುವ ಆವರ್ತನ ಅಥವಾ ಅವರು ಅನುಮತಿಸುವದನ್ನು ಅವಲಂಬಿಸಿ, ವಿಭಿನ್ನ ರೀತಿಯ ಸರ್ಕ್ಯೂಟ್‌ಗಳಿವೆ:

• ಕಡಿಮೆ ಪಾಸ್ ಫಿಲ್ಟರ್: ಅವುಗಳು ಕಡಿಮೆ ಆವರ್ತನಗಳನ್ನು ಹಾದುಹೋಗಲು ಮತ್ತು ನಿಗ್ರಹಿಸಲು ಅಥವಾ ಹೆಚ್ಚಿನ ಆವರ್ತನಗಳ ಪಾಸ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಅನುಮತಿಸುವ ಫಿಲ್ಟರ್‌ಗಳಾಗಿರುವುದರಿಂದ ಅವುಗಳನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ. ಅವು ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಸುರುಳಿಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ (ವಿದ್ಯುತ್ ಸರಬರಾಜು ಮತ್ತು ಹೊರೆಯೊಂದಿಗೆ ಸರಣಿಯಲ್ಲಿ), ಮತ್ತು ವಿದ್ಯುತ್ ಸರಬರಾಜು ಮತ್ತು ಹೊರೆಯೊಂದಿಗೆ ಒಂದು ಅಥವಾ ಎರಡು ಷಂಟ್ ಕೆಪಾಸಿಟರ್ಗಳು. ಲೋಡ್ ಅನ್ನು ಫಿಲ್ಟರ್‌ಗೆ ಸಂಪರ್ಕಿಸಲಾದ ಸಾಧನವೆಂದು ತಿಳಿಯಲಾಗಿದೆ ಮತ್ತು ಅದು ಫಿಲ್ಟರ್‌ನ output ಟ್‌ಪುಟ್ ಅನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ ... ಈ ಫಿಲ್ಟರ್‌ಗಳ ಒಳಗೆ ಎಲ್, ಟಿ ಮತ್ತು π.
• ಹೆಚ್ಚಿನ ಪಾಸ್ ಫಿಲ್ಟರ್: ಹೆಚ್ಚಿನ ಪಾಸ್ ಫಿಲ್ಟರ್ ಕಡಿಮೆ ಪಾಸ್ಗೆ ವಿರುದ್ಧವಾಗಿರುತ್ತದೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಕಡಿಮೆ ಆವರ್ತನ ಪಾಸ್ ಅನ್ನು ಫಿಲ್ಟರ್ ಅಥವಾ ಮಿತಿಗೊಳಿಸುವುದು ಹೆಚ್ಚಿನ ಆವರ್ತನಗಳನ್ನು ಹಾದುಹೋಗಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇದರಲ್ಲಿ ಅದನ್ನು ರಚಿಸುವ ಎಲೆಕ್ಟ್ರಾನಿಕ್ ಅಂಶಗಳನ್ನು ಹೂಡಿಕೆ ಮಾಡಲಾಗುತ್ತದೆ. ಅಂದರೆ, ಇಲ್ಲಿ ಕೆಪಾಸಿಟರ್ಗಳು ವಿದ್ಯುತ್ ಸರಬರಾಜು ಮತ್ತು ಹೊರೆಯೊಂದಿಗೆ ಸರಣಿಯಲ್ಲಿರುತ್ತವೆ, ಆದರೆ ಸುರುಳಿಗಳನ್ನು ಮುಚ್ಚಲಾಗುತ್ತದೆ. ಕಡಿಮೆ ಪಾಸ್ ಫಿಲ್ಟರ್‌ಗಳಂತೆಯೇ ಅದೇ ಉಪವಿಭಾಗಗಳಿವೆ.
• ಬ್ಯಾಂಡ್ ಪಾಸ್ ಫಿಲ್ಟರ್: ಈ ರೀತಿಯ ಫಿಲ್ಟರ್ ಎರಡು ಆವರ್ತನ ಬ್ಯಾಂಡ್ ಪಾಸ್ ದರ ಲಾಕ್‌ಗಳನ್ನು ನೀಡುತ್ತದೆ. ಅಂದರೆ, ಅವು ಕಡಿಮೆ ಪಾಸ್ ಫಿಲ್ಟರ್ ಆಗಿ ಮತ್ತು ಹೆಚ್ಚಿನ ಪಾಸ್ ಫಿಲ್ಟರ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, ಕಡಿಮೆ ಆವರ್ತನಗಳ ಅಂಗೀಕಾರವನ್ನು ವಿರೋಧಿಸುತ್ತವೆ ಮತ್ತು ಅದೇ ಸಮಯದಲ್ಲಿ ಅತಿ ಹೆಚ್ಚು. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಇದು ಮಧ್ಯದ ಆವರ್ತನಗಳನ್ನು ಹಾದುಹೋಗಲು ಮಾತ್ರ ಅನುಮತಿಸುತ್ತದೆ.
• ಬ್ಯಾಂಡ್ ಫಿಲ್ಟರ್: ಇದು ಹಿಂದಿನದಕ್ಕೆ ನಿಖರವಾಗಿ ವಿರುದ್ಧವಾಗಿರುತ್ತದೆ, ಅದು ಏನು ಮಾಡುತ್ತದೆ ಎಂದರೆ ಅದು ಮಧ್ಯ ಆವರ್ತನಗಳ ಪಾಸ್ ಅನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಕಡಿಮೆ ಮತ್ತು ಹೆಚ್ಚಿನ ಆವರ್ತನಗಳ ಮೂಲಕ ಮಾತ್ರ ಅನುಮತಿಸುತ್ತದೆ.

ಅದನ್ನು ನೆನಪಿಡಿ ಇಂಡಕ್ಟನ್ಸ್ ಅವರು ಕಡಿಮೆ ಆವರ್ತನಗಳ ಮೂಲಕ ಅವಕಾಶ ನೀಡುತ್ತಾರೆ ಮತ್ತು ಹೆಚ್ಚಿನ ಆವರ್ತನಗಳ ಅಂಗೀಕಾರವನ್ನು ವಿರೋಧಿಸುತ್ತಾರೆ. ಬದಲಾಗಿ, ಕೆಪಾಸಿಟರ್ಗಳು ಅವರು ಹೆಚ್ಚಿನ ಆವರ್ತನಗಳ ಮೂಲಕ ಅವಕಾಶ ನೀಡುತ್ತಾರೆ ಮತ್ತು ಕಡಿಮೆ ಆವರ್ತನಗಳ ಅಂಗೀಕಾರವನ್ನು ವಿರೋಧಿಸುತ್ತಾರೆ.

ಆ ಫಿಲ್ಟರ್‌ಗಳನ್ನು ಪ್ರಾಯೋಗಿಕ ಮಟ್ಟದಲ್ಲಿ ಸೇರಿಸಲು ನಾನು ಬಯಸುತ್ತೇನೆ ಅವರು ಪರಿಪೂರ್ಣರಲ್ಲ, ಮತ್ತು ಅವರು ಯಾವಾಗಲೂ ನೀವು ನಿರ್ಬಂಧಿಸಬೇಕಾದ ಕೆಲವು ಕಡಿಮೆ ಅಥವಾ ಹೆಚ್ಚಿನ ಆವರ್ತನಗಳನ್ನು ರವಾನಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಹೆಚ್ಚಿನ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಅವರು ತಮ್ಮ ಕೆಲಸವನ್ನು ಚೆನ್ನಾಗಿ ಮಾಡುತ್ತಾರೆ.

ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾನು ಇನ್ನೊಂದು ವಿಷಯವನ್ನು ಸ್ಪಷ್ಟಪಡಿಸಲು ಬಯಸುತ್ತೇನೆ, ಮತ್ತು ನೀವು ಖಂಡಿತವಾಗಿಯೂ ಅದರ ಬಗ್ಗೆ ಕೇಳಿದ್ದೀರಿ EMA ಮತ್ತು DEMA ಫಿಲ್ಟರ್‌ಗಳು. ಎಂಬೆಡೆಡ್ ಸಾಧನಗಳಲ್ಲಿ ಈ ರೀತಿಯ ಫಿಲ್ಟರ್ ಅನ್ನು ಸರಳ ರೀತಿಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಇಎಂಎ (ಘಾತೀಯ ಚಲಿಸುವ ಸರಾಸರಿ) ಫಿಲ್ಟರ್‌ಗಳು ನಿಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ. ಡೆಮಾ (ಡಬಲ್ ಎಕ್ಸ್‌ಪೋನೆನ್ಶಿಯಲ್ ಮೂವಿಂಗ್ ಸರಾಸರಿ) ಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ಅವು ಇಎಂಎಗಿಂತ ವೇಗವಾಗಿ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹೊಂದಿವೆ, ನೀವು ತಪ್ಪಿಸಲು ಬಯಸುವ ಶಬ್ದವನ್ನು ಉತ್ತಮವಾಗಿ ನಿಗ್ರಹಿಸುತ್ತವೆ.

ಆಲ್ಫಾ ಅಂಶ

El ಆಲ್ಫಾ ಅಂಶ, ಮುಂದಿನ ವಿಭಾಗದಲ್ಲಿ ಆರ್ಡುನೊ ಐಡಿಇ ಕೋಡ್‌ಗಳಲ್ಲಿ ಗೋಚರಿಸುವುದನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ, ಇದು ಘಾತೀಯ ಫಿಲ್ಟರ್‌ನ ನಡವಳಿಕೆಯನ್ನು ನಿಯಂತ್ರಿಸುವ ನಿಯತಾಂಕವಾಗಿದೆ. ಇದು ಕಟ್ಆಫ್ ಆವರ್ತನಕ್ಕೆ ಸಂಬಂಧಿಸಿದೆ:

• ಆಲ್ಫಾ = 1: ಅದು ಫಿಲ್ಟರ್ ಮಾಡದ .ಟ್‌ಪುಟ್‌ಗೆ ಸಂಕೇತವನ್ನು ನೀಡುತ್ತದೆ.
• ಆಲ್ಫಾ = 0: ಫಿಲ್ಟರ್ ಮೌಲ್ಯವು ಯಾವಾಗಲೂ 0 ಆಗಿರುತ್ತದೆ.
• ಆಲ್ಫಾ = x: ಇತರ ಮೌಲ್ಯಗಳು ಇಎಂಎ ಫಿಲ್ಟರ್‌ನಲ್ಲಿ ಇತರ ಬದಲಾವಣೆಗಳನ್ನು ಪಡೆಯಬಹುದು. ನೀವು ಆಲ್ಫಾ ಅಂಶವನ್ನು ಕಡಿಮೆ ಮಾಡಿದರೆ, ನೀವು ಹೆಚ್ಚು ಪಡೆದ ಆವರ್ತನ ಸಂಕೇತವನ್ನು ಮೃದುಗೊಳಿಸುತ್ತೀರಿ, ಮತ್ತು ವ್ಯವಸ್ಥೆಯ ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯವೂ ಹೆಚ್ಚಾಗುತ್ತದೆ (ಇದು ಸ್ಥಿರಗೊಳ್ಳಲು ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ).

ಫಿಲ್ಟರ್‌ಗಳು ಮತ್ತು ಆರ್ಡುನೊ

ಸರ್ಕ್ಯೂಟ್ ಅನ್ನು ರಚಿಸುವುದು ಅನಿವಾರ್ಯವಲ್ಲ ಎಂದು ನೀವು ತಿಳಿದಿರಬೇಕು ಹೈ ಪಾಸ್ ಫಿಲ್ಟರ್ ಅಥವಾ ಕಡಿಮೆ ಪಾಸ್ ಫಿಲ್ಟರ್ ಅದನ್ನು ನಿಮ್ಮ ಆರ್ಡುನೊ ಬೋರ್ಡ್‌ಗೆ ಸಂಪರ್ಕಿಸಲು ಮತ್ತು ಅದರೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು. ನೀವು ಈ ರೀತಿಯ ಸರಳ ಫಿಲ್ಟರ್‌ಗಳನ್ನು ಪ್ರಯೋಗಿಸಬಹುದು ಮತ್ತು ರಚಿಸಬಹುದಾದರೂ, ಕೇವಲ ಆರ್ಡುನೊ ಬೋರ್ಡ್ ಮತ್ತು ಆರ್ಡುನೊ ಐಡಿಇಗಾಗಿ ಸರಳ ಕೋಡ್‌ನೊಂದಿಗೆ ಇಎಂಎ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಸಹ ನೀವು ಪರೀಕ್ಷಿಸಬಹುದು. ಕೆಲವು ಆವರ್ತನಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವ ಉಸ್ತುವಾರಿ ಹೇಗೆ ಎಂದು ನೀವು ನೋಡಬೇಕಾದ ಏಕೈಕ ವಿಷಯವೆಂದರೆ (ಈ ಸಂದರ್ಭದಲ್ಲಿ ಕ್ರಿಯೆಯನ್ನು ಅನುಕರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಕೆಲವು ಪೂರ್ಣಾಂಕಗಳು / ಫ್ಲೋಟ್‌ಗಳನ್ನು ಸರಳವಾಗಿ ಫಿಲ್ಟರ್ ಮಾಡಲಾಗುತ್ತದೆ ನಾನು ಏನು ಮಾಡುತ್ತೇನೆ ಎಂದು ಅನುಕರಿಸುವುದು ವಾಸ್ತವವಾಗಿ ಫಿಲ್ಟರ್ ಮಾಡಿ).

ಅಭ್ಯಾಸ ಮಾಡಲು ನೀವು ಬಳಸಬಹುದಾದ ಕೆಲವು ಕೋಡ್ ಮಾದರಿಗಳು ಇಲ್ಲಿವೆ.

ಆರ್ಡುನೊ ಪ್ರಕಾರದ ಸರಳ ಡಿಜಿಟಲ್ ಫಿಲ್ಟರ್‌ನ ಉದಾಹರಣೆ ಕಡಿಮೆ ಪಾಸ್:

float   lowpass_prev_out[LOWPASS_ANALOG_PIN_AMT], 
         lowpass_cur_out[LOWPASS_ANALOG_PIN_AMT];
int        lowpass_input[LOWPASS_ANALOG_PIN_AMT];
 
 
int adcsample_and_lowpass(int pin, int sample_rate, int samples, float alpha, char use_previous) {
  // pin:            Pin analógico de Arduino usado
  // sample_rate:    El ratio adecuado
  // samples:        Samples
  // alpha:          El factor Alpha para el filtro paso bajo
  // use_previous:   Si es true se sigue ajustando hasta el valor más reciente. 
 
  float one_minus_alpha = 1.0-alpha;
  int micro_delay=max(100, (1000000/sample_rate) - 160);  
  if (!use_previous) { 
    lowpass_input[pin] = analogRead(pin);
    lowpass_prev_out[pin]=lowpass_input[pin]; 
  }
  int i;
  for (i=samples;i>0;i--) {
    delayMicroseconds(micro_delay);
    lowpass_input[pin] = analogRead(pin);
    lowpass_cur_out[pin] = alpha*lowpass_input[pin] + one_minus_alpha*lowpass_prev_out[pin];
    lowpass_prev_out[pin]=lowpass_cur_out[pin];
  }
  return lowpass_cur_out[pin];
}
 
int resulting_value;
 
void setup() {
   Serial.begin(9600);
   resulting_value = adcsample_and_lowpass(0, 1000, 300, 0.015, false); 
}
 
void loop() {
   resulting_value = adcsample_and_lowpass(0, 1000, 150, 0.015, true);  
   Serial.println(resulting_value);

ಆರ್ಡುನೊ ಪ್ರಕಾರಕ್ಕೆ ಕೋಡ್ ಉದಾಹರಣೆ ಹೈ ಪಾಸ್:

int sensorPin = 0;    //pin usado para el ADC
int sensorValue = 0;  //Inicia sensor variable equivalente a EMA Y
float EMA_a = 0.3;    //Inicialización del EMA Alpha
int EMA_S = 0;        //Iniciación del EMA s
int highpass = 0;
 
void setup(){
  Serial.begin(115200);              
  EMA_S = analogRead(sensorPin);     
}
 
void loop(){
  sensorValue = analogRead(sensorPin);              //Lee el valor del sensor ADC
  EMA_S = (EMA_a*sensorValue) + ((1-EMA_a)*EMA_S);  //Ejecuta el filtro EMA
  highpass = sensorValue - EMA_S;                   //Calcula la seña alta
 
  Serial.println(highpass);
   
  delay(20);                                //Espera 20ms
}

ಆರ್ಡುನೊ ಕೋಡ್ ಉದಾಹರಣೆ ಬ್ಯಾಂಡ್ ಪಾಸ್:

int sensorPin = 0;        //Pin para el ADC
int sensorValue = 0;      //Inicia la variable del sensor, equivale a EMA Y
 
float EMA_a_low = 0.3;    //Inicia EMA Alpha
float EMA_a_high = 0.5;
 
int EMA_S_low = 0;        //Inicia EMA S
int EMA_S_high = 0;
 
int highpass = 0;
int bandpass = 0;
 
void setup(){
  Serial.begin(115200);                   
   
  EMA_S_low = analogRead(sensorPin);      
  EMA_S_high = analogRead(sensorPin);
}
 
void loop(){
  sensorValue = analogRead(sensorPin);    //Lee el valor del sensor ADC
   
  EMA_S_low = (EMA_a_low*sensorValue) + ((1-EMA_a_low)*EMA_S_low);  //Ejecuta EMA
  EMA_S_high = (EMA_a_high*sensorValue) + ((1-EMA_a_high)*EMA_S_high);
   
  highpass = sensorValue - EMA_S_low;     
  bandpass = EMA_S_high - EMA_S_low;     
 
  Serial.print(highpass);
  Serial.print(" ");
  Serial.println(bandpass);
   
  delay(20);                              
}

ಆರ್ಡುನೊ ಕೋಡ್ ಉದಾಹರಣೆ ಬ್ಯಾಂಡ್ಗಾಗಿ:

int sensorPin = 0;          //Pin usado para el ADC
int sensorValue = 0;        //Inicio para EMA Y
 
float EMA_a_low = 0.05;     //Inicio de EMA alpha 
float EMA_a_high = 0.4;
 
int EMA_S_low = 0;          //Inicia EMA S
int EMA_S_high = 0;
 
int highpass = 0;
int bandpass = 0;
int bandstop = 0;
 
void setup(){
  Serial.begin(115200);                     
   
  EMA_S_low = analogRead(sensorPin);        
  EMA_S_high = analogRead(sensorPin);
}
 
void loop(){
  sensorValue = analogRead(sensorPin);      //Lee el valor del sensor ADC
   
  EMA_S_low = (EMA_a_low*sensorValue) + ((1-EMA_a_low)*EMA_S_low);          //Ejecuta EMA
  EMA_S_high = (EMA_a_high*sensorValue) + ((1-EMA_a_high)*EMA_S_high);
   
  bandpass = EMA_S_high - EMA_S_low;       
 
  bandstop = sensorValue - bandpass;        
 
  Serial.print(sensorValue);
  Serial.print(" ");
  Serial.print(EMA_S_low);
  Serial.print(" ");
  Serial.println(bandstop);
   
  delay(20);                                
}

ಈ ಕೋಡ್‌ಗಳನ್ನು ಮಾರ್ಪಡಿಸಲು ಮತ್ತು ಪ್ರಯೋಗಿಸಲು ನಾನು ನಿಮಗೆ ಸಲಹೆ ನೀಡುತ್ತೇನೆ. ನೀವು ಮಾಡಬಹುದಾದ ಫಲಿತಾಂಶ ಬಹಳ ಸಚಿತ್ರವಾಗಿ ನೋಡಿ ಆರ್ಡುನೊ ಐಡಿಇಯ ಸೀರಿಯಲ್ ಪ್ಲಾಟರ್‌ಗೆ ಧನ್ಯವಾದಗಳು ... ನೀವು ಆರ್ಡುನೊ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬಗ್ಗೆ ಅಥವಾ ಐಡಿಇ ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬ ಬಗ್ಗೆ ಪ್ರಶ್ನೆಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ನೀವು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು PDF ನಲ್ಲಿ ಉಚಿತ HwLibre ಕೋರ್ಸ್.