സൗജന്യമായ ത്രെഡ് പിച്ചിന്റെ കാൽക്കുലേറ്റർ 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 (Unified National Coarse) ബോൾട്ടിന് 20 ത്രെഡുകൾ പ്രതി ഇഞ്ച് ഉണ്ട്.
ഒരു സാധാരണ M10 coarse ത്രെഡിന് 1.5mm പിച്ച് ഉണ്ട്.
ഒരു 3/8-ഇഞ്ച് UNF (Unified National Fine) ബോൾട്ടിന് 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`);
211# ത്രെഡ് പിച്ച് കണക്കാക്കലുകൾക്കുള്ള പൈത്തൺ ഫംഗ്ഷനുകൾ
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")
231' ത്രെഡുകൾ പ്രതി ഇഞ്ചിൽ നിന്ന് പിച്ച് കണക്കാക്കാൻ എക്സൽ ഫോർമുല
2=IF(A1<=0,0,1/A1)
3
4' പിച്ച് മൂല്യത്തിൽ നിന്ന് ത്രെഡുകൾ പ്രതി ഇഞ്ച് കണക്കാക്കാൻ എക്സൽ ഫോർമുല
5=IF(B1<=0,0,1/B1)
6
7' A1 ത്രെഡുകൾ പ്രതി ഇഞ്ച് മൂല്യം ഉൾക്കൊള്ളുന്നു
8' B1 പിച്ച് മൂല്യം ഉൾക്കൊള്ളുന്നു
91// ത്രെഡ് പിച്ച് കണക്കാക്കലുകൾക്കുള്ള ജാവാ മെത്തഡുകൾ
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}
281#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ത്രെഡ് പിച്ച് കണക്കാക്കലുകൾ വിവിധ മേഖലകളിലും ആപ്ലിക്കേഷനുകളിലും അത്യാവശ്യമാണ്:
നിങ്ങളുടെ പ്രവർത്തനത്തിന് ഉപയോഗപ്പെടുന്ന കൂടുതൽ ഉപകരണങ്ങൾ കണ്ടെത്തുക.