คำนวณว่าคานสามารถรองรับน้ำหนักเฉพาะได้อย่างปลอดภัยตามประเภทคาน, วัสดุ, และขนาด วิเคราะห์คานรูปสี่เหลี่ยม, คานรูป I, และคานกลมที่ทำจากเหล็ก, ไม้, หรืออะลูมิเนียม
แคลคูลเลเตอร์ความปลอดภัยของการรับน้ำหนักของคาน เป็นเครื่องมือที่สำคัญสำหรับวิศวกร มืออาชีพด้านการก่อสร้าง และผู้ที่ทำ DIY ที่ต้องการกำหนดว่าคานสามารถรองรับน้ำหนักที่เฉพาะเจาะจงได้อย่างปลอดภัยหรือไม่ แคลคูลเลเตอร์นี้ให้วิธีการที่ตรงไปตรงมาในการประเมินความปลอดภัยของคานโดยการวิเคราะห์ความสัมพันธ์ระหว่างน้ำหนักที่ใช้และความสามารถทางโครงสร้างของประเภทคานและวัสดุต่าง ๆ โดยการป้อนพารามิเตอร์พื้นฐาน เช่น ขนาดของคาน คุณสมบัติของวัสดุ และน้ำหนักที่ใช้ คุณสามารถกำหนดได้อย่างรวดเร็วว่าการออกแบบคานของคุณเป็นไปตามข้อกำหนดด้านความปลอดภัยสำหรับโครงการของคุณหรือไม่
การคำนวณน้ำหนักของคานเป็นพื้นฐานในการวิศวกรรมโครงสร้างและความปลอดภัยในการก่อสร้าง ไม่ว่าคุณจะออกแบบโครงสร้างที่อยู่อาศัย วางแผนอาคารพาณิชย์ หรือทำงานในโครงการปรับปรุงบ้าน DIY ความเข้าใจเกี่ยวกับความปลอดภัยของการรับน้ำหนักของคานเป็นสิ่งสำคัญเพื่อป้องกันการล้มเหลวของโครงสร้างที่อาจนำไปสู่ความเสียหายต่อทรัพย์สิน การบาดเจ็บ หรือแม้แต่การเสียชีวิต แคลคูลเลเตอร์นี้ทำให้หลักการวิศวกรรมโครงสร้างที่ซับซ้อนกลายเป็นรูปแบบที่เข้าถึงได้ ทำให้คุณสามารถตัดสินใจได้อย่างมีข้อมูลเกี่ยวกับการเลือกและการออกแบบคานของคุณ
ความปลอดภัยของการรับน้ำหนักของคานถูกกำหนดโดยการเปรียบเทียบความเครียดที่เกิดจากน้ำหนักที่ใช้กับความเครียดที่อนุญาตของวัสดุคาน เมื่อมีการใช้แรงกดทับลงบนคาน จะเกิดความเครียดภายในที่คานต้องทนทาน หากความเครียดเหล่านี้เกินกว่าความสามารถของวัสดุ คานอาจเกิดการเปลี่ยนรูปถาวรหรือเกิดการล้มเหลวอย่างร้ายแรง
ปัจจัยหลักที่กำหนดความปลอดภัยของการรับน้ำหนักของคานประกอบด้วย:
แคลคูลเลเตอร์ของเรามุ่งเน้นไปที่คานที่รองรับอย่างง่าย (รองรับที่ทั้งสองด้าน) โดยมีน้ำหนักที่ใช้ที่กลาง ซึ่งเป็นการกำหนดค่าที่พบได้บ่อยในแอปพลิเคชันทางโครงสร้างหลาย ๆ ประเภท
หลักการพื้นฐานที่อยู่เบื้องหลังความปลอดภัยของการรับน้ำหนักของคานคือสมการความเครียดจากการดัด:
โดยที่:
สำหรับคานที่รองรับอย่างง่ายที่มีน้ำหนักที่ใช้ที่กลาง โมเมนต์การดัดสูงสุดจะเกิดขึ้นที่กลางและคำนวณได้ดังนี้:
โดยที่:
เพื่อทำให้การคำนวณง่ายขึ้น วิศวกรมักจะใช้โมเมนต์ของความเฉื่อย () ซึ่งรวมโมเมนต์ของความเฉื่อยและระยะทางไปยังเส้นใยสุดขีด:
ซึ่งทำให้เราสามารถเขียนสมการความเครียดจากการดัดใหม่ได้ว่า:
ปัจจัยความปลอดภัยคืออัตราส่วนของน้ำหนักที่อนุญาตสูงสุดกับน้ำหนักที่ใช้:
ปัจจัยความปลอดภัยที่มากกว่า 1.0 แสดงว่าคานสามารถรองรับน้ำหนักได้อย่างปลอดภัย ในทางปฏิบัติ วิศวกรมักจะออกแบบให้มีปัจจัยความปลอดภัยระหว่าง 1.5 ถึง 3.0 ขึ้นอยู่กับแอปพลิเคชันและความไม่แน่นอนในการประมาณน้ำหนัก
โมเมนต์ของความเฉื่อยจะแตกต่างกันไปตามรูปทรงหน้าตัดของคาน:
คานสี่เหลี่ยมผืนผ้า: โดยที่ = ความกว้างและ = ความสูง
คานกลม: โดยที่ = เส้นผ่านศูนย์กลาง
คาน I: โดยที่ = ความกว้างของฟลานจ์, = ความสูงทั้งหมด, = ความหนาของเว็บ, และ = ความหนาของฟลานจ์
แคลคูลเลเตอร์ของเราทำให้การคำนวณที่ซับซ้อนเหล่านี้กลายเป็นรูปแบบที่ใช้งานง่าย ทำตามขั้นตอนเหล่านี้เพื่อกำหนดว่าคานของคุณสามารถรองรับน้ำหนักที่ตั้งใจได้อย่างปลอดภัยหรือไม่:
เลือกจากประเภทหน้าตัดคานสามประเภทที่พบได้บ่อย:
เลือกวัสดุของคาน:
ป้อนขนาดตามประเภทคานที่เลือก:
สำหรับคาน สี่เหลี่ยมผืนผ้า:
สำหรับ คาน I:
สำหรับคาน กลม:
หลังจากป้อนพารามิเตอร์ทั้งหมดแล้ว แคลคูลเลเตอร์จะแสดง:
การแสดงภาพจะให้ภาพรวมของคานที่มีน้ำหนักที่ใช้และระบุว่าปลอดภัย (สีเขียว) หรือไม่ปลอดภัย (สีแดง)
แคลคูลเลเตอร์ของเราใช้คุณสมบัติของวัสดุต่อไปนี้สำหรับการคำนวณความเครียด:
| วัสดุ | ความเครียดที่อนุญาต (MPa) | ความหนาแน่น (kg/m³) |
|---|---|---|
| เหล็ก | 250 | 7850 |
| ไม้ | 10 | 700 |
| อลูมิเนียม | 100 | 2700 |
ค่าดังกล่าวแสดงถึงความเครียดที่อนุญาตทั่วไปสำหรับการใช้งานทางโครงสร้าง สำหรับการใช้งานที่สำคัญ ควรปรึกษากฎการออกแบบเฉพาะวัสดุหรือวิศวกรโครงสร้าง
แคลคูลเลเตอร์ความปลอดภัยของการรับน้ำหนักของคานมีค่าอย่างยิ่งสำหรับ:
เจ้าของบ้านและผู้รับเหมาอาจใช้แคลคูลเลเตอร์นี้สำหรับ:
ผู้ที่ชื่นชอบ DIY จะพบว่าแคลคูลเลเตอร์นี้มีประโยชน์สำหรับ:
ในสภาพแวดล้อมอุตสาหกรรม แคลคูลเลเตอร์นี้สามารถช่วยในการ:
ในขณะที่แคลคูลเลเตอร์ของเราให้การประเมินความปลอดภัยของคานที่ตรงไปตรงมา แต่ก็มีวิธีการทางเลือกสำหรับสถานการณ์ที่ซับซ้อนมากขึ้น:
เลือกวิธีการที่ตรงกับความซับซ้อนของโครงการของคุณและผลกระทบจากการล้มเหลวที่อาจเกิดขึ้น
หลักการที่อยู่เบื้องหลังแคลคูลเลเตอร์ความปลอดภัยของการรับน้ำหนักของคานของเราได้พัฒนาขึ้นจากการพัฒนาทางวิทยาศาสตร์และวิศวกรรมในช่วงหลายศตวรรษ:
ทฤษฎีคานมีรากฐานมาจากอารยธรรมโบราณ ชาวโรมัน ชาวอียิปต์ และชาวจีนล้วนพัฒนาวิธีการเชิงประจักษ์ในการกำหนดขนาดคานที่เหมาะสมสำหรับโครงสร้างของพวกเขา วิศวกรในยุคแรกเหล่านี้พึ่งพาประสบการณ์และการทดลองมากกว่าการวิเคราะห์ทางคณิตศาสตร์
รากฐานทางคณิตศาสตร์ของทฤษฎีคานเริ่มต้นในศตวรรษที่ 17 และ 18:
ศตวรรษที่ 19 มีการพัฒนาทฤษฎีคานและการประยุกต์ใช้อย่างรวดเร็ว:
การวิเคราะห์โครงสร้างในปัจจุบันรวมทฤษฎีคานคลาสสิกเข้ากับวิธีการคอมพิวเตอร์ขั้นสูง:
แคลคูลเลเตอร์ของเราสร้างขึ้นจากประวัติศาสตร์ที่อุดมไปด้วยนี้ ทำให้ความรู้ทางวิศวกรรมหลายศตวรรษสามารถเข้าถึงได้ผ่านส่วนติดต่อที่เรียบง่าย
เจ้าของบ้านต้องการตรวจสอบว่าคานไม้พื้นสามารถรองรับอ่างอาบน้ำหนักมากใหม่ได้หรือไม่:
ผลลัพธ์: แคลคูลเลเตอร์แสดงว่าคานนี้ปลอดภัยโดยมีปัจจัยความปลอดภัย 1.75
วิศวกรกำลังออกแบบคานรองรับสำหรับอาคารพาณิชย์ขนาดเล็ก:
ผลลัพธ์: แคลคูลเลเตอร์แสดงว่าคานนี้ปลอดภัยโดยมีปัจจัยความปลอดภัย 2.3
ผู้ผลิตป้ายต้องการตรวจสอบว่าเสาอลูมิเนียมสามารถรองรับป้ายร้านค้าใหม่ได้หรือไม่:
ผลลัพธ์: แคลคูลเลเตอร์แสดงว่าคานนี้ไม่ปลอดภัยโดยมีปัจจัยความปลอดภัย 0.85 ซึ่งบ่งชี้ว่าต้องใช้เสาเส้นผ่านศูนย์กลางที่ใหญ่กว่า
นี่คือตัวอย่างวิธีการดำเนินการคำนวณความปลอดภัยของคานในภาษาการเขียนโปรแกรมต่าง ๆ:
1// การดำเนินการใน JavaScript สำหรับการตรวจสอบความปลอดภัยของคานสี่เหลี่ยมผืนผ้า
2function checkRectangularBeamSafety(width, height, length, load, material) {
3 // คุณสมบัติของวัสดุใน MPa
4 const allowableStress = {
5 steel: 250,
6 wood: 10,
7 aluminum: 100
8 };
9
10 // คำนวณโมเมนต์ของความเฉื่อย (m^4)
11 const I = (width * Math.pow(height, 3)) / 12;
12
13 // คำนวณโมเมนต์ของความเฉื่อย (m^3)
14 const S = I / (height / 2);
15
16 // คำนวณโมเมนต์การดัดสูงสุด (N·m)
17 const M = (load * length) / 4;
18
19 // คำนวณความเครียดที่เกิดขึ้นจริง (MPa)
20 const stress = M / S;
21
22 // คำนวณปัจจัยความปลอดภัย
23 const safetyFactor = allowableStress[material] / stress;
24
25 // คำนวณน้ำหนักที่อนุญาตสูงสุด (N)
26 const maxAllowableLoad = load * safetyFactor;
27
28 return {
29 safe: safetyFactor >= 1,
30 safetyFactor,
31 maxAllowableLoad,
32 stress,
33 allowableStress: allowableStress[material]
34 };
35}
36
37// ตัวอย่างการใช้งาน
38const result = checkRectangularBeamSafety(0.1, 0.2, 3, 5000, 'steel');
39console.log(`คาน ${result.safe ? 'ปลอดภัย' : 'ไม่ปลอดภัย'}`);
40console.log(`ปัจจัยความปลอดภัย: ${result.safetyFactor.toFixed(2)}`);
411import math
2
3def check_circular_beam_safety(diameter, length, load, material):
4 """
5 ตรวจสอบว่าคานกลมสามารถรองรับน้ำหนักที่กำหนดได้อย่างปลอดภัยหรือไม่
6
7 พารามิเตอร์:
8 diameter (float): เส้นผ่านศูนย์กลางของคานเป็นเมตร
9 length (float): ความยาวของคานเป็นเมตร
10 load (float): น้ำหนักที่ใช้เป็นนิวตัน
11 material (str): 'steel', 'wood', หรือ 'aluminum'
12
13 คืนค่า:
14 dict: ผลลัพธ์การประเมินความปลอดภัย
15 """
16 # คุณสมบัติของวัสดุ (MPa)
17 allowable_stress = {
18 'steel': 250,
19 'wood': 10,
20 'aluminum': 100
21 }
22
23 # คำนวณโมเมนต์ของความเฉื่อย (m^4)
24 I = (math.pi * diameter**4) / 64
25
26 # คำนวณโมเมนต์ของความเฉื่อย (m^3)
27 S = I / (diameter / 2)
28
29 # คำนวณโมเมนต์การดัดสูงสุด (N·m)
30 M = (load * length) / 4
31
32 # คำนวณความเครียดที่เกิดขึ้นจริง (MPa)
33 stress = M / S
34
35 # คำนวณปัจจัยความปลอดภัย
36 safety_factor = allowable_stress[material] / stress
37
38 # คำนวณน้ำหนักที่อนุญาตสูงสุด (N)
39 max_allowable_load = load * safety_factor
40
41 return {
42 'safe': safety_factor >= 1,
43 'safety_factor': safety_factor,
44 'max_allowable_load': max_allowable_load,
45 'stress': stress,
46 'allowable_stress': allowable_stress[material]
47 }
48
49# ตัวอย่างการใช้งาน
50beam_params = check_circular_beam_safety(0.05, 2, 1000, 'aluminum')
51print(f"คาน { 'ปลอดภัย' if beam_params['safe'] else 'ไม่ปลอดภัย' }")
52print(f"ปัจจัยความปลอดภัย: {beam_params['safety_factor']:.2f}")
531public class IBeamSafetyCalculator {
2 // คุณสมบัติของวัสดุใน MPa
3 private static final double STEEL_ALLOWABLE_STRESS = 250.0;
4 private static final double WOOD_ALLOWABLE_STRESS = 10.0;
5 private static final double ALUMINUM_ALLOWABLE_STRESS = 100.0;
6
7 public static class SafetyResult {
8 public boolean isSafe;
9 public double safetyFactor;
10 public double maxAllowableLoad;
11 public double stress;
12 public double allowableStress;
13
14 public SafetyResult(boolean isSafe, double safetyFactor, double maxAllowableLoad,
15 double stress, double allowableStress) {
16 this.isSafe = isSafe;
17 this.safetyFactor = safetyFactor;
18 this.maxAllowableLoad = maxAllowableLoad;
19 this.stress = stress;
20 this.allowableStress = allowableStress;
21 }
22 }
23
24 public static SafetyResult checkIBeamSafety(
25 double height, double flangeWidth, double flangeThickness,
26 double webThickness, double length, double load, String material) {
27
28 // รับความเครียดที่อนุญาตตามวัสดุ
29 double allowableStress;
30 switch (material.toLowerCase()) {
31 case "steel": allowableStress = STEEL_ALLOWABLE_STRESS; break;
32 case "wood": allowableStress = WOOD_ALLOWABLE_STRESS; break;
33 case "aluminum": allowableStress = ALUMINUM_ALLOWABLE_STRESS; break;
34 default: throw new IllegalArgumentException("วัสดุไม่รู้จัก: " + material);
35 }
36
37 // คำนวณโมเมนต์ของความเฉื่อยสำหรับคาน I
38 double webHeight = height - 2 * flangeThickness;
39 double outerI = (flangeWidth * Math.pow(height, 3)) / 12;
40 double innerI = ((flangeWidth - webThickness) * Math.pow(webHeight, 3)) / 12;
41 double I = outerI - innerI;
42
43 // คำนวณโมเมนต์ของความเฉื่อย (m^3)
44 double S = I / (height / 2);
45
46 // คำนวณโมเมนต์การดัดสูงสุด
47 double M = (load * length) / 4;
48
49 // คำนวณความเครียดที่เกิดขึ้นจริง
50 double stress = M / S;
51
52 // คำนวณปัจจัยความปลอดภัย
53 double safetyFactor = allowableStress / stress;
54
55 return new SafetyResult(
56 safetyFactor >= 1.0,
57 safetyFactor,
58 load * safetyFactor,
59 stress,
60 allowableStress
61 );
62 }
63
64 public static void main(String[] args) {
65 // ตัวอย่าง: ตรวจสอบความปลอดภัยของคาน I
66 SafetyResult result = checkIBeamSafety(
67 0.2, // ความสูง (m)
68 0.1, // ความกว้างของฟลานจ์ (m)
69 0.015, // ความหนาของฟลานจ์ (m)
70 0.01, // ความหนาของเว็บ (m)
71 4.0, // ความยาว (m)
72 15000, // น้ำหนักที่ใช้ (N)
73 "steel" // วัสดุ
74 );
75
76 System.out.println("คาน " + (result.isSafe ? "ปลอดภัย" : "ไม่ปลอดภัย"));
77 System.out.printf("ปัจจัยความปลอดภัย: %.2f\n", result.safetyFactor);
78 System.out.printf("น้ำหนักที่อนุญาตสูงสุด: %.2f N\n", result.maxAllowableLoad);
79 }
80}
811' ฟังก์ชัน Excel VBA สำหรับการตรวจสอบความปลอดภัยของคานสี่เหลี่ยมผืนผ้า
2Function CheckRectangularBeamSafety(Width As Double, Height As Double, Length As Double, Load As Double, Material As String) As Variant
3 Dim I As Double
4 Dim S As Double
5 Dim M As Double
6 Dim Stress As Double
7 Dim AllowableStress As Double
8 Dim SafetyFactor As Double
9 Dim MaxAllowableLoad As Double
10 Dim Result(1 To 5) As Variant
11
12 ' กำหนดความเครียดที่อนุญาตตามวัสดุ (MPa)
13 Select Case LCase(Material)
14 Case "steel"
15 AllowableStress = 250
16 Case "wood"
17 AllowableStress = 10
18 Case "aluminum"
19 AllowableStress = 100
20 Case Else
21 CheckRectangularBeamSafety = "วัสดุไม่ถูกต้อง"
22 Exit Function
23 End Select
24
25 ' คำนวณโมเมนต์ของความเฉื่อย (m^4)
26 I = (Width * Height ^ 3) / 12
27
28 ' คำนวณโมเมนต์ของความเฉื่อย (m^3)
29 S = I / (Height / 2)
30
31 ' คำนวณโมเมนต์การดัดสูงสุด (N·m)
32 M = (Load * Length) / 4
33
34 ' คำนวณความเครียดที่เกิดขึ้นจริง (MPa)
35 Stress = M / S
36
37 ' คำนวณปัจจัยความปลอดภัย
38 SafetyFactor = AllowableStress / Stress
39
40 ' คำนวณน้ำหนักที่อนุญาตสูงสุด (N)
41 MaxAllowableLoad = Load * SafetyFactor
42
43 ' เตรียมอาร์เรย์ผลลัพธ์
44 Result(1) = SafetyFactor >= 1 ' ปลอดภัย?
45 Result(2) = SafetyFactor ' ปัจจัยความปลอดภัย
46 Result(3) = MaxAllowableLoad ' น้ำหนักที่อนุญาตสูงสุด
47 Result(4) = Stress ' ความเครียดที่เกิดขึ้นจริง
48 Result(5) = AllowableStress ' ความเครียดที่อนุญาต
49
50 CheckRectangularBeamSafety = Result
51End Function
52
53' การใช้งานในเซลล์ Excel:
54' =CheckRectangularBeamSafety(0.1, 0.2, 3, 5000, "steel")
551#include <iostream>
2#include <cmath>
3#include <string>
4#include <map>
5
6struct BeamSafetyResult {
7 bool isSafe;
8 double safetyFactor;
9 double maxAllowableLoad;
10 double stress;
11 double allowableStress;
12};
13
14// คำนวณความปลอดภัยสำหรับคานกลม
15BeamSafetyResult checkCircularBeamSafety(
16 double diameter, double length, double load, const std::string& material) {
17
18 // คุณสมบัติของวัสดุ (MPa)
19 std::map<std::string, double> allowableStress = {
20 {"steel", 250.0},
21 {"wood", 10.0},
22 {"aluminum", 100.0}
23 };
24
25 // คำนวณโมเมนต์ของความเฉื่อย (m^4)
26 double I = (M_PI * std::pow(diameter, 4)) / 64.0;
27
28 // คำนวณโมเมนต์ของความเฉื่อย (m^3)
29 double S = I / (diameter / 2.0);
30
31 // คำนวณโมเมนต์การดัดสูงสุด (N·m)
32 double M = (load * length) / 4.0;
33
34 // คำนวณความเครียดที่เกิดขึ้นจริง (MPa)
35 double stress = M / S;
36
37 // คำนวณปัจจัยความปลอดภัย
38 double safetyFactor = allowableStress[material] / stress;
39
40 // คำนวณน้ำหนักที่อนุญาตสูงสุด (N)
41 double maxAllowableLoad = load * safetyFactor;
42
43 return {
44 safetyFactor >= 1.0,
45 safetyFactor,
46 maxAllowableLoad,
47 stress,
48 allowableStress[material]
49 };
50}
51
52int main() {
53 // ตัวอย่าง: ตรวจสอบความปลอดภัยของคานกลม
54 double diameter = 0.05; // เมตร
55 double length = 2.0; // เมตร
56 double load = 1000.0; // นิวตัน
57 std::string material = "steel";
58
59 BeamSafetyResult result = checkCircularBeamSafety(diameter, length, load, material);
60
61 std::cout << "คาน " << (result.isSafe ? "ปลอดภัย" : "ไม่ปลอดภัย") << std::endl;
62 std::cout << "ปัจจัยความปลอดภัย: " << result.safetyFactor << std::endl;
63 std::cout << "น้ำหนักที่อนุญาตสูงสุด: " << result.maxAllowableLoad << " N" << std::endl;
64
65 return 0;
66}
67แคลคูลเลเตอร์ความปลอดภัยของการรับน้ำหนักของคานเป็นเครื่องมือที่ช่วยกำหนดว่าคานสามารถรองรับน้ำหนักที่เฉพาะเจาะจงได้อย่างปลอดภัยหรือไม่ โดยวิเคราะห์ความสัมพันธ์ระหว่างขนาดของคาน คุณสมบัติของวัสดุ และน้ำหนักที่ใช้เพื่อคำนวณระดับความเครียดและปัจจัยความปลอดภัย
แคลคูลเลเตอร์นี้ให้การประมาณที่ดีสำหรับการกำหนดค่าคานที่เรียบง่ายที่มีน้ำหนักที่ใช้ที่กลาง มันใช้สูตรวิศวกรรมมาตรฐานและคุณสมบัติของวัสดุ สำหรับสถานการณ์การโหลดที่ซับซ้อน วัสดุที่ไม่เป็นมาตรฐาน หรือแอปพลิเคชันที่สำคัญ ควรปรึกษาวิศวกรโครงสร้าง
โดยทั่วไป แนะนำให้ใช้ปัจจัยความปลอดภัยอย่างน้อย 1.5 สำหรับแอปพลิเคชันส่วนใหญ่ โครงสร้างที่สำคัญอาจต้องการปัจจัยความปลอดภัย 2.0 หรือสูงกว่า รหัสอาคารมักกำหนดปัจจัยความปลอดภัยขั้นต่ำสำหรับแอปพลิเคชันต่าง ๆ
แคลคูลเลเตอร์นี้ออกแบบมาสำหรับน้ำหนักคงที่ น้ำหนักพลศาสตร์ (เช่น เครื่องจักรที่เคลื่อนที่ ลม หรือแรงสั่นสะเทือน) ต้องการการพิจารณาเพิ่มเติมและมักจะต้องการปัจจัยความปลอดภัยที่สูงกว่า สำหรับการโหลดพลศาสตร์ ควรปรึกษาวิศวกรโครงสร้าง
แคลคูลเลเตอร์รองรับวัสดุโครงสร้างสามประเภทที่พบได้บ่อย ได้แก่ เหล็ก ไม้ และอลูมิเนียม วัสดุแต่ละชนิดมีคุณสมบัติความแข็งแรงที่แตกต่างกันซึ่งมีผลต่อความสามารถในการรองรับน้ำหนักของคาน
วัดขนาดจริงของคานของคุณเป็นเมตร สำหรับคานสี่เหลี่ยมผืนผ้าให้วัดความกว้างและความสูง สำหรับคาน I ให้วัดความสูงทั้งหมด ความกว้างของฟลานจ์ ความหนาของฟลานจ์ และความหนาของเว็บ สำหรับคานกลมให้วัดเส้นผ่านศูนย์กลาง
ผลลัพธ์ "ไม่ปลอดภัย" แสดงว่าน้ำหนักที่ใช้เกินความสามารถในการรองรับน้ำหนักของคาน อาจทำให้เกิดการโก่งตัวที่มากเกินไป การเปลี่ยนรูปถาวร หรือการล้มเหลวอย่างร้ายแรง คุณควรลดน้ำหนักที่ใช้ ลดระยะห่างระหว่างการรองรับ หรือเลือกคานที่แข็งแรงกว่า
แคลคูลเลเตอร์นี้มุ่งเน้นไปที่ความปลอดภัยด้านความเครียดมากกว่าการโก่งตัว แม้ว่าคานที่ "ปลอดภัย" จากมุมมองด้านความเครียดอาจโก่งตัว (งอ) มากกว่าที่ต้องการสำหรับแอปพลิเคชันของคุณ สำหรับการคำนวณการโก่งตัวจะต้องใช้เครื่องมือเพิ่มเติม
ไม่ แคลคูลเลเตอร์นี้ออกแบบมาสำหรับคานที่รองรับอย่างง่าย (รองรับที่ทั้งสองด้าน) โดยมีน้ำหนักที่ใช้ที่กลาง คานที่ยื่นออกมามีการกระจายโหลดและความเครียดที่แตกต่างกัน
รูปทรงหน้าตัดของคานที่แตกต่างกันจะกระจายวัสดุแตกต่างกันไปตามแกนกลาง คาน I มีประสิทธิภาพโดยเฉพาะเพราะมันวางวัสดุมากขึ้นห่างจากแกนกลาง ซึ่งเพิ่มโมเมนต์ของความเฉื่อยและความสามารถในการรับน้ำหนักสำหรับวัสดุที่กำหนด
Gere, J. M., & Goodno, B. J. (2012). Mechanics of Materials (8th ed.). Cengage Learning.
Hibbeler, R. C. (2018). Structural Analysis (10th ed.). Pearson.
American Institute of Steel Construction. (2017). Steel Construction Manual (15th ed.). AISC.
American Wood Council. (2018). National Design Specification for Wood Construction. AWC.
Aluminum Association. (2020). Aluminum Design Manual. The Aluminum Association.
International Code Council. (2021). International Building Code. ICC.
Timoshenko, S. P., & Gere, J. M. (1972). Mechanics of Materials. Van Nostrand Reinhold Company.
Beer, F. P., Johnston, E. R., DeWolf, J. T., & Mazurek, D. F. (2020). Mechanics of Materials (8th ed.). McGraw-Hill Education.
อย่ารับความเสี่ยงจากการล้มเหลวของโครงสร้างในโครงการถัดไปของคุณ ใช้แคลคูลเลเตอร์ความปลอดภัยของการรับน้ำหนักของคานของเราเพื่อให้แน่ใจว่าคานของคุณสามารถรองรับน้ำหนักที่ตั้งใจได้อย่างปลอดภัย เพียงป้อนขนาดของคาน วัสดุ และข้อมูลน้ำหนักเพื่อรับการประเมินความปลอดภัยทันที
สำหรับความต้องการการวิเคราะห์โครงสร้างที่ซับซ้อนมากขึ้น ให้พิจารณาปรึกษาวิศวกรโครงสร้างมืออาชีพที่สามารถให้คำแนะนำที่เหมาะสมสำหรับแอปพลิเคชันเฉพาะของคุณ
ค้นพบเครื่องมือเพิ่มเติมที่อาจมีประโยชน์สำหรับการทำงานของคุณ