ಉಚಿತ ಥ್ರೆಡ್ ಪಿಚ್ ಕ್ಯಾಲ್ಕುಲೇಟರ್ TPI ಅನ್ನು ಪಿಚ್ ಗೆ ಮತ್ತು ವಿರುದ್ಧವಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ. ಇಂಪೀರಿಯಲ್ ಮತ್ತು ಮೆಟ್ರಿಕ್ ಥ್ರೆಡ್ಗಳಿಗೆ ಥ್ರೆಡ್ ಪಿಚ್ ಅನ್ನು ಲೆಕ್ಕಹಾಕಿ. ಯಂತ್ರೋಪಕರಣ, ಎಂಜಿನಿಯರಿಂಗ್ ಮತ್ತು ದುರಸ್ತಿ ಕಾರ್ಯಗಳಿಗೆ ತಕ್ಷಣದ ಫಲಿತಾಂಶಗಳು.
ಥ್ರೆಡ್ ಪಿಚ್ ಅಡ್ಜೆಸೆಂಟ್ ಥ್ರೆಡ್ಗಳ ನಡುವಿನ ಅಂತರವಾಗಿದೆ. ಇದು ಯೂನಿಟ್ ಉದ್ದಕ್ಕೆ ಥ್ರೆಡ್ಗಳ ಸಂಖ್ಯೆಯ ವ್ಯತಿರೇಕವಾಗಿ ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ:
ಒಂದು ಥ್ರೆಡ್ ಪಿಚ್ ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಎಂದರೆ ಇಂಚುಗೆ ಥ್ರೆಡ್ಗಳ ಸಂಖ್ಯೆಯನ್ನು (TPI) ಪಿಚ್ ಅಳತೆಯಲ್ಲಿಗೆ ಮತ್ತು ಅದರ ವಿರುದ್ಧಕ್ಕೆ ಪರಿವರ್ತಿಸುವ ಶ್ರೇಣೀಬದ್ಧ ಸಾಧನ, ಥ್ರೆಡ್ ಫಾಸ್ಟನರ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಎಂಜಿನಿಯರ್ಗಳು, ಮೆಷಿನಿಸ್ಟ್ಗಳು ಮತ್ತು DIY ಉತ್ಸಾಹಿಗಳಿಗಾಗಿ ಅಗತ್ಯವಿದೆ. ಥ್ರೆಡ್ ಪಿಚ್ ಎಂದರೆ ಹತ್ತಿರದ ಥ್ರೆಡ್ ಕ್ರೆಸ್ಟ್ಗಳ ನಡುವಿನ ಅಂತರವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಮತ್ತು ಇಂಪೀರಿಯಲ್ ಮತ್ತು ಮೆಟ್ರಿಕ್ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಥ್ರೆಡ್ ಸಂಪರ್ಕಗಳ ಹೊಂದಾಣಿಕೆಯನ್ನು ನಿರ್ಧಾರಿಸುತ್ತದೆ.
ಈ ಉಚಿತ ಥ್ರೆಡ್ ಪಿಚ್ ಕ್ಯಾಲ್ಕುಲೇಟರ್ ತಕ್ಷಣವೇ ಇಂಚಿಗೆ ಥ್ರೆಡ್ಗಳ (TPI) ಮತ್ತು ಪಿಚ್ ಅಳತೆಯ ನಡುವಿನ ಪರಿವರ್ತನೆಗಳನ್ನು ಮಾಡುತ್ತದೆ, ಕೈಯಿಂದ ಲೆಕ್ಕಹಾಕುವಿಕೆಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ಮತ್ತು ಮೆಷಿನಿಂಗ್, ಎಂಜಿನಿಯರಿಂಗ್ ಮತ್ತು ದುರಸ್ತಿ ಯೋಜನೆಗಳಲ್ಲಿ ದುಬಾರಿ ಅಳತೆಯ ದೋಷಗಳನ್ನು ತಡೆಯುತ್ತದೆ. ನೀವು ಬದಲಾವಣೆ ಫಾಸ್ಟನರ್ಗಳನ್ನು ಗುರುತಿಸುತ್ತಿದ್ದೀರಾ ಅಥವಾ CNC ಯಂತ್ರಗಳನ್ನು ಪ್ರೋಗ್ರಾಮ್ ಮಾಡುತ್ತಿದ್ದೀರಾ, ನಿಖರವಾದ ಥ್ರೆಡ್ ಪಿಚ್ ಲೆಕ್ಕಹಾಕುವಿಕೆಗಳು ಸರಿಯಾದ ಹೊಂದಾಣಿಕೆ ಮತ್ತು ಕಾರ್ಯಕ್ಕಾಗಿ ಅತ್ಯಂತ ಮುಖ್ಯವಾಗಿದೆ.
ನಮ್ಮ ಕ್ಯಾಲ್ಕುಲೇಟರ್ನ್ನು ಬಳಸಿಕೊಂಡು ಸಮಯವನ್ನು ಉಳಿಸಿ ಮತ್ತು ನಿಖರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿ, ಇದು ಇಂಪೀರಿಯಲ್ ಥ್ರೆಡ್ ನಿರ್ದಿಷ್ಟತೆಗಳನ್ನು (UNC, UNF) ಮತ್ತು ಮೆಟ್ರಿಕ್ ಥ್ರೆಡ್ ಮಾನದಂಡಗಳನ್ನು (ISO ಮೆಟ್ರಿಕ್) ಬೆಂಬಲಿಸುತ್ತದೆ, ಇದು ನಿಮ್ಮ ಎಲ್ಲಾ ಥ್ರೆಡ್ ಅಳತೆ ಅಗತ್ಯಗಳಿಗೆ ಸಂಪೂರ್ಣ ಪರಿಹಾರವಾಗುತ್ತದೆ.
ಥ್ರೆಡ್ ಪಿಚ್ ಎಂದರೆ ಥ್ರೆಡ್ ಅಕ್ಷಕ್ಕೆ ಸಮಾಂತರವಾಗಿ ಅಳೆಯುವ ಹತ್ತಿರದ ಥ್ರೆಡ್ ಕ್ರೆಸ್ಟ್ಗಳ (ಅಥವಾ ರೂಟ್ಗಳ) ನಡುವಿನ ರೇಖೀಯ ಅಂತರ. ಇದು ಥ್ರೆಡ್ಗಳ ಹತ್ತಿರದ ಅಂತರವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಮತ್ತು ಫಾಸ್ಟನರ್ ಹೊಂದಾಣಿಕೆಯನ್ನು ನಿರ್ಧಾರಿಸುತ್ತದೆ. ಥ್ರೆಡ್ ಪಿಚ್ ಅನ್ನು ಅಳೆಯಲಾಗುತ್ತದೆ:
ಪ್ರಮುಖ ಸಂಬಂಧ: ಥ್ರೆಡ್ ಪಿಚ್ = 1 ÷ ಘಟಕ ಉದ್ದಕ್ಕೆ ಥ್ರೆಡ್ಗಳು
ಈ ಅಳತೆಯು ಸರಿಯಾದ ಫಾಸ್ಟನರ್ ಆಯ್ಕೆ, ಮೆಷಿನಿಂಗ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ಥ್ರೆಡ್ ಭಾಗಗಳು ಸರಿಯಾಗಿ ಹೊಂದಿಕೊಳ್ಳುವಂತೆ ಖಚಿತಪಡಿಸಲು ಅಗತ್ಯವಿದೆ.
ಇಂಪೀರಿಯಲ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ಥ್ರೆಡ್ಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಅವರ ವ್ಯಾಸ ಮತ್ತು ಇಂಚಿಗೆ ಥ್ರೆಡ್ಗಳ ಸಂಖ್ಯೆಯ ಮೂಲಕ ನಿರ್ದಿಷ್ಟಗೊಳಿಸಲಾಗುತ್ತದೆ (TPI). ಉದಾಹರಣೆಗೆ, 1/4"-20 ಸ್ಕ್ರೂಗೆ 1/4-ಇಂಚು ವ್ಯಾಸವಿದೆ ಮತ್ತು 20 ಥ್ರೆಡ್ಗಳು ಇಂಚಿಗೆ ಇವೆ.
ಮೆಟ್ರಿಕ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ಥ್ರೆಡ್ಗಳನ್ನು ಅವರ ವ್ಯಾಸ ಮತ್ತು ಮಿಲಿಮೀಟರ್ಗಳಲ್ಲಿ ಪಿಚ್ ಮೂಲಕ ನಿರ್ದಿಷ್ಟಗೊಳಿಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, M6×1.0 ಸ್ಕ್ರೂಗೆ 6mm ವ್ಯಾಸವಿದೆ ಮತ್ತು 1.0mm ಪಿಚ್ ಇದೆ.
ಈ ಅಳತೆಗಳ ನಡುವಿನ ಸಂಬಂಧ ಸರಳವಾಗಿದೆ:
ಥ್ರೆಡ್ ಪಿಚ್ ಮತ್ತು ಥ್ರೆಡ್ ಲೀಡ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಗುರುತಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ:
ಒಂದು ಸಿಂಗಲ್-ಸ್ಟಾರ್ಟ್ ಥ್ರೆಡ್ಗಳಿಗೆ (ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ಪ್ರಕಾರ), ಪಿಚ್ ಮತ್ತು ಲೀಡ್ ಒಂದೇ. ಆದರೆ, ಬಹು-ಸ್ಟಾರ್ಟ್ ಥ್ರೆಡ್ಗಳಿಗೆ, ಲೀಡ್ ಪಿಚ್ ಅನ್ನು ಸ್ಟಾರ್ಟ್ಗಳ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಗುಣಿಸುತ್ತವೆ.
ಘಟಕ ಉದ್ದಕ್ಕೆ ಥ್ರೆಡ್ಗಳು ಮತ್ತು ಥ್ರೆಡ್ ಪಿಚ್ ನಡುವಿನ ಗಣಿತೀಯ ಸಂಬಂಧವು ಸರಳ ವಿರೋಧ ಸಂಬಂಧವನ್ನು ಆಧಾರಿತವಾಗಿದೆ:
ಇಂಪೀರಿಯಲ್ ಥ್ರೆಡ್ಗಳಿಗೆ, ಸೂತ್ರವು:
ಉದಾಹರಣೆಗೆ, 20 TPI ಇರುವ ಥ್ರೆಡ್ಗೆ ಪಿಚ್:
ಮೆಟ್ರಿಕ್ ಥ್ರೆಡ್ಗಳಿಗೆ, ಸೂತ್ರವು:
ಉದಾಹರಣೆಗೆ, 0.5 ಥ್ರೆಡ್ಗಳು ಪ್ರತಿ mm ಇರುವ ಥ್ರೆಡ್ಗೆ ಪಿಚ್:
ನಮ್ಮ ಥ್ರೆಡ್ ಪಿಚ್ ಕ್ಯಾಲ್ಕುಲೇಟರ್ TPI ಮತ್ತು ಪಿಚ್ ಅಳತೆಗಳ ನಡುವಿನ ತಕ್ಷಣದ, ನಿಖರವಾದ ಪರಿವರ್ತನೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಉಚಿತ ಸಾಧನವು ವೃತ್ತಿಪರರು ಮತ್ತು DIY ಉತ್ಸಾಹಿಗಳಿಗಾಗಿ ಥ್ರೆಡ್ ಪಿಚ್ ಲೆಕ್ಕಹಾಕುವಿಕೆಗಳನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.
ನಿಮ್ಮ ಘಟಕ ವ್ಯವಸ್ಥೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡಿ:
ಜ್ಞಾನಿತ ಮೌಲ್ಯಗಳನ್ನು ನಮೂದಿಸಿ:
ಫಲಿತಾಂಶಗಳನ್ನು ನೋಡಿ:
ಫಲಿತಾಂಶಗಳನ್ನು ನಕಲಿಸಿ (ಐಚ್ಛಿಕ):
ಒಂದು ಪ್ರಮಾಣಿತ 1/4-ಇಂಚು UNC (ಯುನಿಫೈಡ್ ನ್ಯಾಷನಲ್ ಕೋರ್ಸ್) ಬೋಲ್ಟ್ಗೆ 20 ಥ್ರೆಡ್ಗಳು ಇಂಚಿಗೆ ಇವೆ.
ಒಂದು ಪ್ರಮಾಣಿತ M10 ಕೋರ್ಸ್ ಥ್ರೆಡ್ಗೆ 1.5mm ಪಿಚ್ ಇದೆ.
ಒಂದು 3/8-ಇಂಚು UNF (ಯುನಿಫೈಡ್ ನ್ಯಾಷನಲ್ ಫೈನ್) ಬೋಲ್ಟ್ಗೆ 24 ಥ್ರೆಡ್ಗಳು ಇಂಚಿಗೆ ಇವೆ.
ಒಂದು ಸೂಕ್ಷ್ಮ M8 ಥ್ರೆಡ್ಗೆ 1.0mm ಪಿಚ್ ಇದೆ.
ಇವು ವಿವಿಧ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಥ್ರೆಡ್ ಪಿಚ್ ಅನ್ನು ಲೆಕ್ಕಹಾಕಲು ಹೇಗೆ ಲೆಕ್ಕಹಾಕುವುದು ಎಂಬ ಉದಾಹರಣೆಗಳು:
1// ಥ್ರೆಡ್ಗಳ ಸಂಖ್ಯೆಯಿಂದ ಥ್ರೆಡ್ ಪಿಚ್ ಅನ್ನು ಲೆಕ್ಕಹಾಕಲು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಾರ್ಯ
2function calculatePitch(threadsPerUnit) {
3 if (threadsPerUnit <= 0) {
4 return 0;
5 }
6 return 1 / threadsPerUnit;
7}
8
9// ಪಿಚ್ನಿಂದ ಘಟಕಕ್ಕೆ ಥ್ರೆಡ್ಗಳನ್ನು ಲೆಕ್ಕಹಾಕಲು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಾರ್ಯ
10function calculateThreadsPerUnit(pitch) {
11 if (pitch <= 0) {
12 return 0;
13 }
14 return 1 / pitch;
15}
16
17// ಉದಾಹರಣೆಯ ಬಳಕೆ
18const tpi = 20;
19const pitch = calculatePitch(tpi);
20console.log(`A thread with ${tpi} TPI has a pitch of ${pitch.toFixed(4)} inches`);
21
1# ಥ್ರೆಡ್ ಪಿಚ್ ಲೆಕ್ಕಹಾಕಲು ಪೈಥಾನ್ ಕಾರ್ಯಗಳು
2
3def calculate_pitch(threads_per_unit):
4 """ಘಟಕಕ್ಕೆ ಥ್ರೆಡ್ಗಳಿಂದ ಥ್ರೆಡ್ ಪಿಚ್ ಅನ್ನು ಲೆಕ್ಕಹಾಕಿ"""
5 if threads_per_unit <= 0:
6 return 0
7 return 1 / threads_per_unit
8
9def calculate_threads_per_unit(pitch):
10 """ಪಿಚ್ನಿಂದ ಘಟಕಕ್ಕೆ ಥ್ರೆಡ್ಗಳನ್ನು ಲೆಕ್ಕಹಾಕಿ"""
11 if pitch <= 0:
12 return 0
13 return 1 / pitch
14
15# ಉದಾಹರಣೆಯ ಬಳಕೆ
16tpi = 20
17pitch = calculate_pitch(tpi)
18print(f"A thread with {tpi} TPI has a pitch of {pitch:.4f} inches")
19
20metric_pitch = 1.5 # mm
21threads_per_mm = calculate_threads_per_unit(metric_pitch)
22print(f"A thread with {metric_pitch}mm pitch has {threads_per_mm:.4f} threads per mm")
23
1' ಇಂಚಿಗೆ ಥ್ರೆಡ್ಗಳಿಂದ ಪಿಚ್ ಅನ್ನು ಲೆಕ್ಕಹಾಕಲು ಎಕ್ಸೆಲ್ ಸೂತ್ರ
2=IF(A1<=0,0,1/A1)
3
4' ಪಿಚ್ನಿಂದ ಇಂಚಿಗೆ ಥ್ರೆಡ್ಗಳನ್ನು ಲೆಕ್ಕಹಾಕಲು ಎಕ್ಸೆಲ್ ಸೂತ್ರ
5=IF(B1<=0,0,1/B1)
6
7' A1 ಇಂಚಿಗೆ ಥ್ರೆಡ್ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ
8' ಮತ್ತು B1 ಪಿಚ್ ಮೌಲ್ಯವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ
9
1// ಥ್ರೆಡ್ ಪಿಚ್ ಲೆಕ್ಕಹಾಕಲು ಜಾವಾ ವಿಧಾನಗಳು
2public class ThreadCalculator {
3 public static double calculatePitch(double threadsPerUnit) {
4 if (threadsPerUnit <= 0) {
5 return 0;
6 }
7 return 1 / threadsPerUnit;
8 }
9
10 public static double calculateThreadsPerUnit(double pitch) {
11 if (pitch <= 0) {
12 return 0;
13 }
14 return 1 / pitch;
15 }
16
17 public static void main(String[] args) {
18 double tpi = 20;
19 double pitch = calculatePitch(tpi);
20 System.out.printf("A thread with %.0f TPI has a pitch of %.4f inches%n", tpi, pitch);
21
22 double metricPitch = 1.5; // mm
23 double threadsPerMm = calculateThreadsPerUnit(metricPitch);
24 System.out.printf("A thread with %.1fmm pitch has %.4f threads per mm%n",
25 metricPitch, threadsPerMm);
26 }
27}
28
1#include <iostream>
2#include <iomanip>
3
4// ಥ್ರೆಡ್ ಪಿಚ್ ಲೆಕ್ಕಹಾಕಲು C++ ಕಾರ್ಯಗಳು
5double calculatePitch(double threadsPerUnit) {
6 if (threadsPerUnit <= 0) {
7 return 0;
8 }
9 return 1 / threadsPerUnit;
10}
11
12double calculateThreadsPerUnit(double pitch) {
13 if (pitch <= 0) {
14 return 0;
15 }
16 return 1 / pitch;
17}
18
19int main() {
20 double tpi = 20;
21 double pitch = calculatePitch(tpi);
22 std::cout << "A thread with " << tpi << " TPI has a pitch of "
23 << std::fixed << std::setprecision(4) << pitch << " inches" << std::endl;
24
25 double metricPitch = 1.5; // mm
26 double threadsPerMm = calculateThreadsPerUnit(metricPitch);
27 std::cout << "A thread with " << metricPitch << "mm pitch has "
28 << std::fixed << std::setprecision(4) << threadsPerMm << " threads per mm" << std::endl;
29
30 return 0;
31}
32
ಥ್ರೆಡ್ ಪಿಚ್ ಲೆಕ್ಕಹಾಕುವಿಕೆಗಳು ವಿವಿಧ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ಗಳಲ್ಲಿ ಅಗತ್ಯವಿದೆ:
ನಿಮ್ಮ ಕೆಲಸದ ಹಂತಕ್ಕೆ ಉಪಯೋಗಿಸಬಹುದಾದ ಹೆಚ್ಚು ಉಪಕರಣಗಳನ್ನು ಹುಡುಕಿ ಹೊಸ ಉಪಕರಣಗಳನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ