Ingyenes menetemelkedés számító átváltja a TPI-t menetemelkedésre és fordítva. Számítsa ki a menetemelkedést imperiális és metrikus menetekhez. Azonnali eredmények megmunkáláshoz, mérnöki munkához és javításokhoz.
A menetemelkedés a szomszédos menetek közötti távolság. A menetek számának az egység hosszra vonatkoztatott reciproka alapján számítják:
A menetemelkedés számító egy precíziós eszköz, amely az inchenkénti menetek számát (TPI) menetemelkedés mérésekké alakítja, és fordítva, elengedhetetlen mérnökök, gépészek és barkácsolók számára, akik menetes rögzítőelemekkel dolgoznak. A menetemelkedés a szomszédos menetcsúcsok közötti távolságot jelenti, és meghatározza a menetes csatlakozások kompatibilitását mind az angolszász, mind a metrikus rendszerekben.
Ez a ingyenes menetemelkedés számító azonnal átvált az inchenkénti menetek (TPI) és a menetemelkedés mérések között, megszüntetve a manuális számításokat és megelőzve a költséges mérési hibákat a megmunkálás, mérnöki és javítási projektek során. Akár csere rögzítőelemeket azonosít, akár CNC gépeket programoz, a pontos menetemelkedés számítások kulcsfontosságúak a megfelelő illeszkedés és működés érdekében.
Takarítson meg időt és biztosítson precizitást a számítónkkal, amely támogatja mind az angolszász menet specifikációkat (mint UNC, UNF), mind a metrikus menet szabványokat (ISO metrikus), így teljes megoldást nyújt minden menetmérés igényéhez.
A menetemelkedés a szomszédos menetcsúcsok (vagy gyökerek) közötti lineáris távolság, amelyet a menet tengelyével párhuzamosan mérnek. Ez jelzi, hogy a menetek mennyire közel helyezkednek el egymáshoz, és meghatározza a rögzítőelemek kompatibilitását. A menetemelkedést a következőképpen mérik:
Kulcs kapcsolat: Menetemelkedés = 1 ÷ menetek egységnyi hosszúságra
Ez a mérés elengedhetetlen a megfelelő rögzítőelem kiválasztásához, a megmunkálási műveletekhez és a menetes alkatrészek helyes illeszkedésének biztosításához.
Az angolszász rendszerben a meneteket jellemzően átmérőjük és az inchenkénti menetek száma (TPI) alapján határozzák meg. Például egy 1/4"-20 csavar 1/4 hüvelyk átmérőjű, 20 menettel inchenként.
A metrikus rendszerben a meneteket átmérőjük és menetemelkedésük milliméterben történő megadásával határozzák meg. Például egy M6×1.0 csavar 6 mm átmérőjű, 1.0 mm menetemelkedéssel.
A mérések közötti kapcsolat egyszerű:
Fontos megkülönböztetni a menetemelkedést és a menetvezetést:
Egyszeri indítású menetek esetén (a leggyakoribb típus) a menetemelkedés és a menetvezetés azonos. Azonban többszörös indítású menetek esetén a vezetés a menetemelkedés és az indítások számának szorzataként egyenlő.
A menetemelkedés és az egységnyi hosszúságra vonatkozó menetek közötti matematikai kapcsolat egy egyszerű inverz kapcsolat alapján áll:
Angolszász menetek esetén a képlet a következőképpen alakul:
Például egy 20 TPI menettel rendelkező menet esetén a menetemelkedés:
Metrikus menetek esetén a képlet:
Például egy 0.5 menettel rendelkező menet esetén a menetemelkedés:
A menetemelkedés számítónk azonnali, pontos átváltásokat biztosít a TPI és a menetemelkedés mérések között. Ez az ingyenes eszköz egyszerűsíti a menetemelkedés számításokat a szakemberek és a barkácsolók számára egyaránt.
Válassza ki az egységrendszert:
Adja meg a megadott értékeket:
Tekintse meg az eredményeket:
Másolja az eredményeket (opcionális):
Egy standard 1/4 hüvelykes UNC (Unified National Coarse) csavar 20 menettel rendelkezik inchenként.
Egy standard M10 durva menet 1.5 mm menetemelkedéssel rendelkezik.
Egy 3/8 hüvelykes UNF (Unified National Fine) csavar 24 menettel rendelkezik inchenként.
Egy finom M8 menet 1.0 mm menetemelkedéssel rendelkezik.
Itt vannak példák arra, hogyan lehet kiszámítani a menetemelkedést különböző programozási nyelvekben:
1// JavaScript függvény a menetemelkedés kiszámításához az egységnyi menetekből
2function calculatePitch(threadsPerUnit) {
3 if (threadsPerUnit <= 0) {
4 return 0;
5 }
6 return 1 / threadsPerUnit;
7}
8
9// JavaScript függvény az egységnyi menetek kiszámításához a menetemelkedésből
10function calculateThreadsPerUnit(pitch) {
11 if (pitch <= 0) {
12 return 0;
13 }
14 return 1 / pitch;
15}
16
17// Példa használat
18const tpi = 20;
19const pitch = calculatePitch(tpi);
20console.log(`A ${tpi} TPI menettel rendelkező menetemelkedése ${pitch.toFixed(4)} hüvelyk`);
211# Python függvények a menetemelkedés számításához
2
3def calculate_pitch(threads_per_unit):
4 """Számítsa ki a menetemelkedést az egységnyi menetekből"""
5 if threads_per_unit <= 0:
6 return 0
7 return 1 / threads_per_unit
8
9def calculate_threads_per_unit(pitch):
10 """Számítsa ki az egységnyi meneteket a menetemelkedésből"""
11 if pitch <= 0:
12 return 0
13 return 1 / pitch
14
15# Példa használat
16tpi = 20
17pitch = calculate_pitch(tpi)
18print(f"A {tpi} TPI menettel rendelkező menetemelkedése {pitch:.4f} hüvelyk")
19
20metric_pitch = 1.5 # mm
21threads_per_mm = calculate_threads_per_unit(metric_pitch)
22print(f"A {metric_pitch} mm menetemelkedésű menettel {threads_per_mm:.4f} menet van mm-ként")
231' Excel képlet a menetemelkedés kiszámításához az inchenkénti menetekből
2=IF(A1<=0,0,1/A1)
3
4' Excel képlet az inchenkénti menetek kiszámításához a menetemelkedésből
5=IF(B1<=0,0,1/B1)
6
7' Ahol A1 tartalmazza az inchenkénti menetek értékét
8' és B1 tartalmazza a menetemelkedés értékét
91// Java metódusok a menetemelkedés számításához
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 %.0f TPI menettel rendelkező menetemelkedése %.4f hüvelyk%n", tpi, pitch);
21
22 double metricPitch = 1.5; // mm
23 double threadsPerMm = calculateThreadsPerUnit(metricPitch);
24 System.out.printf("A %.1f mm menetemelkedésű menettel %.4f menet van mm-ként%n",
25 metricPitch, threadsPerMm);
26 }
27}
281#include <iostream>
2#include <iomanip>
3
4// C++ függvények a menetemelkedés számításához
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 " << tpi << " TPI menettel rendelkező menetemelkedése "
23 << std::fixed << std::setprecision(4) << pitch << " hüvelyk" << std::endl;
24
25 double metricPitch = 1.5; // mm
26 double threadsPerMm = calculateThreadsPerUnit(metricPitch);
27 std::cout << "A " << metricPitch << " mm menetemelkedésű menettel "
28 << std::fixed << std::setprecision(4) << threadsPerMm << " menet van mm-ként" << std::endl;
29
30 return 0;
31}
32A menetemelkedés számítások elengedhetetlenek különböző területeken és alkalmazásokban:
Fedezzen fel több olyan eszközt, amely hasznos lehet a munkafolyamatához