இலவச துண்டு பிச்சு கணக்கீட்டாளர் TPI ஐ பிச்சுக்கு மற்றும் மாறாக மாற்றுகிறது. இம்பீரியல் மற்றும் மெட்ரிக் துண்டுகளுக்கான துண்டு பிச்சை கணக்கிடுங்கள். இயந்திரம், பொறியியல் மற்றும் பழுதுபார்க்கும் பணிகளுக்கான உடனடி முடிவுகள்.
தூண் பிச்சு அருகிலுள்ள நூல்களின் இடைவெளி ஆகும். இது அலகு நீளத்திற்கு நூல்களின் எண்ணிக்கையின் எதிர்மறையாகக் கணக்கிடப்படுகிறது:
ஒரு த்ரெட் பிச்சு கணக்கீட்டாளர் என்பது துல்லியமான கருவி ஆகும், இது ஒரு அங்குலத்திற்கு உள்ள த்ரெட்கள் (TPI) மற்றும் பிச்சு அளவீடுகளை மாற்றுகிறது, இது த்ரெட் ஃபாஸ்டனர்களுடன் வேலை செய்யும் பொறியாளர்கள், இயந்திரவியல் மற்றும் DIY ஆர்வலர்களுக்கு அவசியமாகும். த்ரெட் பிச்சு என்பது அருகிலுள்ள த்ரெட் கிரெஸ்டுகளுக்கிடையிலான தூரத்தை பிரதிபலிக்கிறது மற்றும் இரு முறைமைகளிலும் த்ரெட் இணைப்புகளின் பொருத்தத்தை தீர்மானிக்கிறது.
இந்த இலவச த்ரெட் பிச்சு கணக்கீட்டாளர் உடனே TPI மற்றும் பிச்சு அளவீடுகளுக்கு இடையே மாற்றுகிறது, கைமுறையாக கணக்கீடுகளை நீக்குகிறது மற்றும் இயந்திரவியல், பொறியியல் மற்றும் பழுது செய்யும் திட்டங்களில் செலவான அளவீட்டு பிழைகளைத் தவிர்க்கிறது. நீங்கள் மாற்று ஃபாஸ்டனர்களை அடையாளம் காண்பதா அல்லது CNC இயந்திரங்களை நிரல்படுத்துவதா, சரியான த்ரெட் பிச்சு கணக்கீடுகள் சரியான பொருத்தம் மற்றும் செயல்பாட்டிற்காக முக்கியமாகும்.
எங்கள் கணக்கீட்டாளரைப் பயன்படுத்தி நேரத்தைச் சேமிக்கவும் மற்றும் துல்லியத்தை உறுதி செய்யவும், இது இரு முறைமைகளின் த்ரெட் விவரக்குறிப்புகளை (UNC, UNF போன்றவை) மற்றும் அளவீட்டு தரநிலைகளை (ISO metric) ஆதரிக்கிறது, இது உங்கள் அனைத்து த்ரெட் அளவீட்டு தேவைகளுக்கான முழுமையான தீர்வாகிறது.
த்ரெட் பிச்சு என்பது த்ரெட் அச்சுக்கு சமமாக அளவிடப்பட்ட அருகிலுள்ள த்ரெட் கிரெஸ்டுகளுக்கிடையிலான நேரியல் தூரமாகும். இது த்ரெட்கள் எவ்வளவு நெருக்கமாக உள்ளன என்பதைக் குறிக்கிறது மற்றும் ஃபாஸ்டனரின் பொருத்தத்தை தீர்மானிக்கிறது. த்ரெட் பிச்சு அளவிடப்படுகிறது:
முக்கிய உறவு: த்ரெட் பிச்சு = 1 ÷ ஒரு அலகு நீளத்திற்கு உள்ள த்ரெட்கள்
இந்த அளவீடு சரியான ஃபாஸ்டனர் தேர்வுக்கு, இயந்திரவியல் செயல்பாடுகள் மற்றும் த்ரெட் கூறுகள் சரியாக பொருந்துவதற்கான உறுதிப்படுத்தலுக்கு அவசியமாகும்.
இம்பீரியல் முறைமையில், த்ரெட்கள் பொதுவாக அவற்றின் விட்டம் மற்றும் ஒரு அங்குலத்திற்கு உள்ள த்ரெட்களின் எண்ணிக்கையால் (TPI) குறிப்பிடப்படுகின்றன. எடுத்துக்காட்டாக, 1/4"-20 ஸ்க்ரூவுக்கு 1/4 அங்குல விட்டம் மற்றும் ஒரு அங்குலத்திற்கு 20 த்ரெட்கள் உள்ளன.
மெட்ரிக் முறைமையில், த்ரெட்கள் அவற்றின் விட்டம் மற்றும் மில்லிமீட்டர்களில் பிச்சு மூலம் குறிப்பிடப்படுகின்றன. எடுத்துக்காட்டாக, M6×1.0 ஸ்க்ரூவுக்கு 6mm விட்டம் மற்றும் 1.0mm பிச்சு உள்ளது.
இந்த அளவீடுகளுக்கிடையிலான உறவு நேர்மையானது:
த்ரெட் பிச்சு மற்றும் த்ரெட் லீட்டுக்கிடையிலான வேறுபாட்டை அடையாளம் காண்பது முக்கியம்:
ஒற்றை தொடக்கம் த்ரெட்களுக்கு (மிகவும் பொதுவான வகை), பிச்சு மற்றும் லீட் ஒரே மாதிரியானவை. இருப்பினும், பல தொடக்கம் த்ரெட்களுக்கு, லீட் என்பது பிச்சு மற்றும் தொடக்கங்களின் எண்ணிக்கையால் பெருக்கப்பட்ட அளவாகும்.
த்ரெட் பிச்சு மற்றும் ஒரு அலகு நீளத்திற்கு உள்ள த்ரெட்கள் இடையிலான கணித உறவு ஒரு எளிய எதிர்மறை உறவின் அடிப்படையில் உள்ளது:
இம்பீரியல் த்ரெட்களுக்கு, சூத்திரம்:
எடுத்துக்காட்டாக, 20 TPI உடைய ஒரு த்ரெட் பிச்சு:
மெட்ரிக் த்ரெட்களுக்கு, சூத்திரம்:
எடுத்துக்காட்டாக, 0.5 த்ரெட்கள் per mm உடைய ஒரு த்ரெட் பிச்சு:
எங்கள் த்ரெட் பிச்சு கணக்கீட்டாளர் TPI மற்றும் பிச்சு அளவீடுகளுக்கு இடையே உடனடி, துல்லியமான மாற்றங்களை வழங்குகிறது. இந்த இலவச கருவி தொழில்முறை மற்றும் DIY ஆர்வலர்களுக்கான த்ரெட் பிச்சு கணக்கீடுகளை எளிதாக்குகிறது.
உங்கள் அலகு முறைமையை தேர்ந்தெடுக்கவும்:
அறியப்பட்ட மதிப்புகளை உள்ளிடவும்:
முடிவுகளைப் பார்வையிடவும்:
முடிவுகளை நகலெடுக்கவும் (விருப்பம்):
ஒரு நிலையான 1/4-அங்குல UNC (Unified National Coarse) பால் 20 த்ரெட்கள் per inch உடையது.
ஒரு நிலையான M10 குரூசு த்ரெட் 1.5mm பிச்சு உடையது.
ஒரு 3/8-அங்குல UNF (Unified National Fine) பால் 24 த்ரெட்கள் per inch உடையது.
ஒரு நுணுக்கமான M8 த்ரெட் 1.0mm பிச்சு உடையது.
விரிவான நிரலாக்க மொழிகளில் த்ரெட் பிச்சுகளை கணக்கீடு செய்வதற்கான எடுத்துக்காட்டுகள் இங்கே உள்ளன:
1// JavaScript செயல்பாடு த்ரெட் பிச்சை த்ரெட்கள் per unit இல் இருந்து கணக்கீடு செய்ய
2function calculatePitch(threadsPerUnit) {
3 if (threadsPerUnit <= 0) {
4 return 0;
5 }
6 return 1 / threadsPerUnit;
7}
8
9// JavaScript செயல்பாடு பிச்சிலிருந்து ஒரு அலகு per threads ஐ கணக்கீடு செய்ய
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# த்ரெட் பிச்சு கணக்கீடுகளுக்கான Python செயல்பாடுகள்
2
3def calculate_pitch(threads_per_unit):
4 """ஒரு அலகு per threads இல் இருந்து த்ரெட் பிச்சை கணக்கீடு செய்க"""
5 if threads_per_unit <= 0:
6 return 0
7 return 1 / threads_per_unit
8
9def calculate_threads_per_unit(pitch):
10 """பிச்சிலிருந்து ஒரு அலகு per threads ஐ கணக்கீடு செய்க"""
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' த்ரெட் பிச்சை த்ரெட்கள் per inch இல் இருந்து கணக்கீடு செய்ய Excel சூத்திரம்
2=IF(A1<=0,0,1/A1)
3
4' பிச்சிலிருந்து த்ரெட்கள் per inch ஐ கணக்கீடு செய்ய Excel சூத்திரம்
5=IF(B1<=0,0,1/B1)
6
7' A1 என்பது த்ரெட்கள் per inch மதிப்பை உள்ளடக்கியது
8' மற்றும் B1 என்பது பிச்சு மதிப்பை உள்ளடக்கியது
91// த்ரெட் பிச்சு கணக்கீடுகளுக்கான Java முறைகள்
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த்ரெட் பிச்சு கணக்கீடுகள் பல துறைகளிலும் பயன்பாடுகளில் முக்கியமானவை:
உங்கள் பணிப்பாக்கிலுக்கு பயனுள்ள மேலும் பயனுள்ள கருவிகளைக் கண்டறியவும்