เครื่องคำนวณเกลียว: แปลง TPI เป็น Pitch ได้ทันที

เครื่องคำนวณเกลียวคืออะไร?

เครื่องคำนวณเกลียว เป็นเครื่องมือที่มีความแม่นยำซึ่งแปลงจำนวนเกลีวยต่อหนึ่งนิ้ว (TPI) เป็นการวัด Pitch และในทางกลับกัน ซึ่งเป็นสิ่งจำเป็นสำหรับวิศวกร ช่างกล และผู้ที่ชื่นชอบการทำ DIY ที่ทำงานกับอุปกรณ์ยึดเกลียว Pitch ของเกลียว แสดงถึงระยะห่างระหว่างยอดเกลียวที่อยู่ติดกันและกำหนดความเข้ากันได้ของการเชื่อมต่อเกลียวในระบบอิมพีเรียลและเมตริก

เครื่องคำนวณเกลียวฟรี นี้จะแปลงระหว่างจำนวนเกลียวต่อหนึ่งนิ้ว (TPI) และการวัด Pitch ได้ทันที โดยไม่ต้องคำนวณด้วยมือและป้องกันข้อผิดพลาดในการวัดที่มีค่าใช้จ่ายสูงในโครงการการกลึง วิศวกรรม และการซ่อมแซม ไม่ว่าคุณจะกำลังระบุอุปกรณ์ยึดที่ต้องเปลี่ยนหรือโปรแกรมเครื่อง CNC การคำนวณ Pitch ของเกลียว ที่แม่นยำเป็นสิ่งสำคัญสำหรับการพอดีและการทำงานที่ถูกต้อง

ประหยัดเวลาและรับประกันความแม่นยำด้วยเครื่องคำนวณของเราที่รองรับทั้งข้อกำหนดเกลียวอิมพีเรียล (เช่น UNC, UNF) และมาตรฐานเกลียวเมตริก (ISO metric) ทำให้เป็นโซลูชันที่ครบถ้วนสำหรับความต้องการ การวัดเกลียว ของคุณทั้งหมด

ทำความเข้าใจกับ Pitch ของเกลียว: คำจำกัดความและแนวคิดหลัก

Pitch ของเกลียว คือระยะทางเชิงเส้นระหว่างยอดเกลียวที่อยู่ติดกัน (หรือราก) ที่วัดขนานกับแกนเกลียว มันแสดงถึงความใกล้ชิดของเกลียวและกำหนดความเข้ากันได้ของอุปกรณ์ยึด Pitch ของเกลียวจะถูกวัดใน:

• ระบบอิมพีเรียล: นิ้ว (ได้มาจาก TPI - จำนวนเกลียวต่อหนึ่งนิ้ว)
• ระบบเมตริก: มิลลิเมตร (ระบุโดยตรง)

ความสัมพันธ์หลัก: Pitch ของเกลียว = 1 ÷ จำนวนเกลียวต่อหน่วยความยาว

การวัดนี้มีความสำคัญสำหรับการเลือกอุปกรณ์ยึดที่ถูกต้อง การดำเนินการกลึง และการรับประกันว่าชิ้นส่วนเกลียวจะพอดีกันอย่างถูกต้อง

ระบบเกลียวอิมพีเรียล vs. เมตริก

ใน ระบบอิมพีเรียล เกลียวมักจะถูกระบุโดยเส้นผ่านศูนย์กลางและจำนวนเกลียวต่อหนึ่งนิ้ว (TPI) ตัวอย่างเช่น สกรูขนาด 1/4"-20 มีเส้นผ่านศูนย์กลาง 1/4 นิ้วและมี 20 เกลียวต่อหนึ่งนิ้ว

ใน ระบบเมตริก เกลียวจะถูกระบุโดยเส้นผ่านศูนย์กลางและ Pitch ในมิลลิเมตร ตัวอย่างเช่น สกรูขนาด M6×1.0 มีเส้นผ่านศูนย์กลาง 6 มม. และมี Pitch 1.0 มม.

ความสัมพันธ์ระหว่างการวัดเหล่านี้เป็นเรื่องง่าย:

• อิมพีเรียล: Pitch (นิ้ว) = 1 ÷ จำนวนเกลียวต่อหนึ่งนิ้ว
• เมตริก: Pitch (มม.) = 1 ÷ จำนวนเกลียวต่อมิลลิเมตร

Pitch ของเกลียว vs. Lead ของเกลียว

สิ่งสำคัญคือต้องแยกแยะระหว่าง Pitch ของเกลียวและ Lead ของเกลียว:

• Pitch ของเกลียว คือระยะห่างระหว่างยอดเกลียวที่อยู่ติดกัน
• Lead ของเกลียว คือระยะทางเชิงเส้นที่สกรูเคลื่อนที่ไปในหนึ่งรอบเต็ม

สำหรับเกลียวแบบเริ่มต้นเดียว (ประเภทที่พบมากที่สุด) Pitch และ Lead จะเหมือนกัน อย่างไรก็ตาม สำหรับเกลียวแบบหลายเริ่ม Lead จะเท่ากับ Pitch คูณด้วยจำนวนเริ่ม

สูตรการคำนวณ Pitch ของเกลียว

ความสัมพันธ์ทางคณิตศาสตร์ระหว่าง Pitch ของเกลียวและจำนวนเกลียวต่อหน่วยความยาวนั้นขึ้นอยู่กับความสัมพันธ์แบบกลับกันที่ง่าย:

สูตรพื้นฐาน

$\text{Pitch} = \frac{1}{\text{Threads Per Unit}}$

$\text{Threads Per Unit} = \frac{1}{\text{Pitch}}$

ระบบอิมพีเรียล (นิ้ว)

สำหรับเกลียวอิมพีเรียล สูตรจะเป็น:

$\text{Pitch (นิ้ว)} = \frac{1}{\text{Threads Per Inch (TPI)}}$

ตัวอย่างเช่น เกลียวที่มี 20 TPI มี Pitch เท่ากับ:

$\text{Pitch} = \frac{1}{20} = 0.050 \text{ นิ้ว}$

ระบบเมตริก (มิลลิเมตร)

สำหรับเกลียวเมตริก สูตรคือ:

$\text{Pitch (มม.)} = \frac{1}{\text{Threads Per mm}}$

ตัวอย่างเช่น เกลียวที่มี 0.5 เกลียวต่อมิลลิเมตรมี Pitch เท่ากับ:

$\text{Pitch} = \frac{1}{0.5} = 2 \text{ มม.}$

วิธีใช้เครื่องคำนวณ Pitch ของเกลียวของเรา: คู่มือทีละขั้นตอน

เครื่องคำนวณ Pitch ของเกลียว ของเรามีการแปลงที่แม่นยำทันทีระหว่าง TPI และการวัด Pitch เครื่องมือนี้ฟรีช่วยให้การคำนวณ Pitch ของเกลียว ง่ายขึ้นสำหรับมืออาชีพและผู้ที่ทำ DIY

คู่มือทีละขั้นตอน

1. เลือกระบบหน่วยของคุณ:

   • เลือก "อิมพีเรียล" สำหรับการวัดในนิ้ว
   • เลือก "เมตริก" สำหรับการวัดในมิลลิเมตร

2. ป้อนค่าที่ทราบ:

   • หากคุณทราบจำนวนเกลียวต่อหน่วย (TPI หรือเกลียวต่อมม.) ให้ป้อนค่าดังกล่าวเพื่อคำนวณ Pitch
   • หากคุณทราบ Pitch ให้ป้อนค่าดังกล่าวเพื่อคำนวณจำนวนเกลียวต่อหน่วย
   • สามารถป้อนเส้นผ่านศูนย์กลางของเกลียวเพื่อการอ้างอิงและการมองเห็นได้

3. ดูผลลัพธ์:

   • เครื่องคำนวณจะคำนวณค่าที่เกี่ยวข้องโดยอัตโนมัติ
   • ผลลัพธ์จะแสดงด้วยความแม่นยำที่เหมาะสม
   • การแสดงภาพของเกลียวจะแสดงตามข้อมูลที่คุณป้อน

4. คัดลอกผลลัพธ์ (ไม่บังคับ):

   • คลิกปุ่ม "คัดลอก" เพื่อคัดลอกผลลัพธ์ไปยังคลิปบอร์ดของคุณเพื่อใช้ในแอปพลิเคชันอื่น

เคล็ดลับสำหรับการวัดที่แม่นยำ

• สำหรับเกลียวอิมพีเรียล TPI มักจะแสดงเป็นจำนวนเต็ม (เช่น 20, 24, 32)
• สำหรับเกลียวเมตริก Pitch มักจะแสดงในมิลลิเมตรโดยมีจุดทศนิยมหนึ่งตำแหน่ง (เช่น 1.0 มม., 1.5 มม., 0.5 มม.)
• เมื่อวัดเกลียวที่มีอยู่ ให้ใช้เครื่องวัด Pitch ของเกลียวเพื่อผลลัพธ์ที่แม่นยำที่สุด
• สำหรับเกลียวที่ละเอียดมาก ให้พิจารณาใช้กล้องจุลทรรศน์หรือแว่นขยายเพื่อนับเกลียวอย่างแม่นยำ

ตัวอย่างการใช้งาน

ตัวอย่างที่ 1: เกลียวอิมพีเรียล (UNC 1/4"-20)

สกรู UNC ขนาด 1/4 นิ้ว (Unified National Coarse) มาตรฐานมี 20 เกลียวต่อหนึ่งนิ้ว

• ข้อมูลนำเข้า: 20 เกลียวต่อหนึ่งนิ้ว (TPI)
• การคำนวณ: Pitch = 1 ÷ 20 = 0.050 นิ้ว
• ผลลัพธ์: Pitch ของเกลียวคือ 0.050 นิ้ว

ตัวอย่างที่ 2: เกลียวเมตริก (M10×1.5)

เกลียว M10 ขนาดหยาบมี Pitch เท่ากับ 1.5 มม.

• ข้อมูลนำเข้า: Pitch 1.5 มม.
• การคำนวณ: เกลียวต่อมม. = 1 ÷ 1.5 = 0.667 เกลียวต่อมม.
• ผลลัพธ์: มี 0.667 เกลียวต่อมิลลิเมตร

ตัวอย่างที่ 3: เกลียวอิมพีเรียลที่ละเอียด (UNF 3/8"-24)

สกรู UNF ขนาด 3/8 นิ้ว (Unified National Fine) มี 24 เกลียวต่อหนึ่งนิ้ว

• ข้อมูลนำเข้า: 24 เกลียวต่อหนึ่งนิ้ว (TPI)
• การคำนวณ: Pitch = 1 ÷ 24 = 0.0417 นิ้ว
• ผลลัพธ์: Pitch ของเกลียวคือ 0.0417 นิ้ว

ตัวอย่างที่ 4: เกลียวเมตริกที่ละเอียด (M8×1.0)

เกลียว M8 ที่ละเอียดมี Pitch เท่ากับ 1.0 มม.

• ข้อมูลนำเข้า: Pitch 1.0 มม.
• การคำนวณ: เกลียวต่อมม. = 1 ÷ 1.0 = 1 เกลียวต่อมม.
• ผลลัพธ์: มี 1 เกลียวต่อมิลลิเมตร

ตัวอย่างโค้ดสำหรับการคำนวณ Pitch ของเกลียว

นี่คือตัวอย่างวิธีการคำนวณ Pitch ของเกลียวในภาษาการเขียนโปรแกรมต่างๆ:

1// ฟังก์ชัน JavaScript สำหรับคำนวณ Pitch ของเกลียวจากจำนวนเกลียวต่อหน่วย
2function calculatePitch(threadsPerUnit) {
3  if (threadsPerUnit <= 0) {
4    return 0;
5  }
6  return 1 / threadsPerUnit;
7}
8
9// ฟังก์ชัน JavaScript สำหรับคำนวณจำนวนเกลียวต่อหน่วยจาก Pitch
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(`เกลียวที่มี ${tpi} TPI มี Pitch เท่ากับ ${pitch.toFixed(4)} นิ้ว`);
21

1# ฟังก์ชัน Python สำหรับการคำนวณ Pitch ของเกลียว
2
3def calculate_pitch(threads_per_unit):
4    """คำนวณ Pitch ของเกลียวจากจำนวนเกลียวต่อหน่วย"""
5    if threads_per_unit <= 0:
6        return 0
7    return 1 / threads_per_unit
8
9def calculate_threads_per_unit(pitch):
10    """คำนวณจำนวนเกลียวต่อหน่วยจาก Pitch"""
11    if pitch <= 0:
12        return 0
13    return 1 / pitch
14
15# การใช้งานตัวอย่าง
16tpi = 20
17pitch = calculate_pitch(tpi)
18print(f"เกลียวที่มี {tpi} TPI มี Pitch เท่ากับ {pitch:.4f} นิ้ว")
19
20metric_pitch = 1.5  # มม.
21threads_per_mm = calculate_threads_per_unit(metric_pitch)
22print(f"เกลียวที่มี Pitch {metric_pitch} มม. มี {threads_per_mm:.4f} เกลียวต่อมม.")
23

1' สูตร Excel สำหรับคำนวณ Pitch จากจำนวนเกลียวต่อหนึ่งนิ้ว
2=IF(A1<=0,0,1/A1)
3
4' สูตร Excel สำหรับคำนวณจำนวนเกลียวต่อหนึ่งนิ้วจาก Pitch
5=IF(B1<=0,0,1/B1)
6
7' โดยที่ A1 มีค่าจำนวนเกลียวต่อหนึ่งนิ้ว
8' และ B1 มีค่า Pitch
9

1// เมธอด Java สำหรับการคำนวณ Pitch ของเกลียว
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("เกลียวที่มี %.0f TPI มี Pitch เท่ากับ %.4f นิ้ว%n", tpi, pitch);
21        
22        double metricPitch = 1.5; // มม.
23        double threadsPerMm = calculateThreadsPerUnit(metricPitch);
24        System.out.printf("เกลียวที่มี Pitch %.1f มม. มี %.4f เกลียวต่อมม.%n", 
25                          metricPitch, threadsPerMm);
26    }
27}
28

1#include <iostream>
2#include <iomanip>
3
4// ฟังก์ชัน C++ สำหรับการคำนวณ Pitch ของเกลียว
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 << "เกลียวที่มี " << tpi << " TPI มี Pitch เท่ากับ " 
23              << std::fixed << std::setprecision(4) << pitch << " นิ้ว" << std::endl;
24    
25    double metricPitch = 1.5; // มม.
26    double threadsPerMm = calculateThreadsPerUnit(metricPitch);
27    std::cout << "เกลียวที่มี Pitch " << metricPitch << " มม. มี " 
28              << std::fixed << std::setprecision(4) << threadsPerMm << " เกลียวต่อมม." << std::endl;
29    
30    return 0;
31}
32

การใช้งานสำหรับการคำนวณ Pitch ของเกลียว

การคำนวณ Pitch ของเกลียวมีความสำคัญในหลายสาขาและการใช้งาน:

การผลิตและวิศวกรรม

• การกลึงที่แม่นยำ: รับประกันข้อกำหนดเกลียวที่ถูกต้องสำหรับชิ้นส่วนที่ต้องพอดีกัน
• การควบคุมคุณภาพ: ตรวจสอบว่าเกลียวที่ผลิตตรงตามข้อกำหนดการออกแบบ
• การวิศวกรรมย้อนกลับ: กำหนดข้อกำหนดของชิ้นส่วนเกลียวที่มีอยู่
• การโปรแกรม CNC: ตั้งค่าเครื่องจักรเพื่อกลึงเกลียวด้วย Pitch ที่ถูกต้อง

การซ่อมแซมและบำรุงรักษาเครื่องจักร

• การเปลี่ยนอุปกรณ์ยึด: ระบุสกรู โบลต์ หรือน็อตที่ต้องเปลี่ยนที่ถูกต้อง
• การซ่อมเกลียว: กำหนดขนาดของแท็บหรือดายที่เหมาะสมสำหรับการฟื้นฟูเกลียว
• การบำรุงรักษาอุปกรณ์: รับประกันการเชื่อมต่อเกลียวที่เข้ากันได้ระหว่างการซ่อมแซม
• งานด้านยานยนต์: ทำงานกับชิ้นส่วนเกลียวทั้งแบบเมตริกและอิมพีเรียล

DIY และโครงการที่บ้าน

• การประกอบเฟอร์นิเจอร์: ระบุอุปกรณ์ยึดที่ถูกต้องสำหรับการประกอบ
• การซ่อมแซมระบบประปา: ทำงานกับข้อกำหนดเกลียวท่อที่ได้มาตรฐาน
• การเลือกฮาร์ดแวร์: เลือกสกรูที่เหมาะสมสำหรับวัสดุและการใช้งานต่างๆ
• การพิมพ์ 3D: ออกแบบชิ้นส่วนเกลียวด้วยระยะห่างที่เหมาะสม

การใช้งานทางวิทยาศาสตร์และการแพทย์

• อุปกรณ์ในห้องปฏิบัติการ: รับประกันความเข้ากันได้ระหว่างชิ้นส่วนเกลียว
• เครื่องมือออปติคัล: ทำงานกับเกลียวที่ละเอียดสำหรับการปรับที่แม่นยำ
• อุปกรณ์ทางการแพทย์: ผลิตชิ้นส่วนที่มีข้อกำหนดเกลียว