แคลคูลเลเตอร์ความปลอดภัยของการรับน้ำหนักของคาน: กำหนดว่าคานของคุณสามารถรองรับน้ำหนักได้หรือไม่

บทนำ

แคลคูลเลเตอร์ความปลอดภัยของการรับน้ำหนักของคาน เป็นเครื่องมือที่สำคัญสำหรับวิศวกร มืออาชีพด้านการก่อสร้าง และผู้ที่ทำ DIY ที่ต้องการกำหนดว่าคานสามารถรองรับน้ำหนักที่เฉพาะเจาะจงได้อย่างปลอดภัยหรือไม่ แคลคูลเลเตอร์นี้ให้วิธีการที่ตรงไปตรงมาในการประเมินความปลอดภัยของคานโดยการวิเคราะห์ความสัมพันธ์ระหว่างน้ำหนักที่ใช้และความสามารถทางโครงสร้างของประเภทคานและวัสดุต่าง ๆ โดยการป้อนพารามิเตอร์พื้นฐาน เช่น ขนาดของคาน คุณสมบัติของวัสดุ และน้ำหนักที่ใช้ คุณสามารถกำหนดได้อย่างรวดเร็วว่าการออกแบบคานของคุณเป็นไปตามข้อกำหนดด้านความปลอดภัยสำหรับโครงการของคุณหรือไม่

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

การเข้าใจความปลอดภัยของการรับน้ำหนักของคาน

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

ปัจจัยหลักที่กำหนดความปลอดภัยของการรับน้ำหนักของคานประกอบด้วย:

1. รูปทรงของคาน (ขนาดและรูปทรงของหน้าตัด)
2. คุณสมบัติของวัสดุ (ความแข็งแรง ความยืดหยุ่น)
3. ขนาดและการกระจายของน้ำหนัก
4. ความยาวของช่วงคาน
5. เงื่อนไขการรองรับ

แคลคูลเลเตอร์ของเรามุ่งเน้นไปที่คานที่รองรับอย่างง่าย (รองรับที่ทั้งสองด้าน) โดยมีน้ำหนักที่ใช้ที่กลาง ซึ่งเป็นการกำหนดค่าที่พบได้บ่อยในแอปพลิเคชันทางโครงสร้างหลาย ๆ ประเภท

วิทยาศาสตร์เบื้องหลังการคำนวณน้ำหนักของคาน

สูตรความเครียดจากการดัด

หลักการพื้นฐานที่อยู่เบื้องหลังความปลอดภัยของการรับน้ำหนักของคานคือสมการความเครียดจากการดัด:

$\sigma = \frac{M \cdot c}{I}$

โดยที่:

• $\sigma$ = ความเครียดจากการดัด (MPa หรือ psi)
• $M$ = โมเมนต์การดัดสูงสุด (N·m หรือ lb·ft)
• $c$ = ระยะห่างจากแกนกลางถึงเส้นใยสุดขีด (m หรือ in)
• $I$ = โมเมนต์ของความเฉื่อยของหน้าตัด (m⁴ หรือ in⁴)

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

$M = \frac{P \cdot L}{4}$

โดยที่:

• $P$ = น้ำหนักที่ใช้ (N หรือ lb)
• $L$ = ความยาวของคาน (m หรือ ft)

โมเมนต์ของความเฉื่อย

เพื่อทำให้การคำนวณง่ายขึ้น วิศวกรมักจะใช้โมเมนต์ของความเฉื่อย ($S$) ซึ่งรวมโมเมนต์ของความเฉื่อยและระยะทางไปยังเส้นใยสุดขีด:

$S = \frac{I}{c}$

ซึ่งทำให้เราสามารถเขียนสมการความเครียดจากการดัดใหม่ได้ว่า:

$\sigma = \frac{M}{S}$

ปัจจัยความปลอดภัย

ปัจจัยความปลอดภัยคืออัตราส่วนของน้ำหนักที่อนุญาตสูงสุดกับน้ำหนักที่ใช้:

$\text{Safety Factor} = \frac{\text{Maximum Allowable Load}}{\text{Applied Load}}$

ปัจจัยความปลอดภัยที่มากกว่า 1.0 แสดงว่าคานสามารถรองรับน้ำหนักได้อย่างปลอดภัย ในทางปฏิบัติ วิศวกรมักจะออกแบบให้มีปัจจัยความปลอดภัยระหว่าง 1.5 ถึง 3.0 ขึ้นอยู่กับแอปพลิเคชันและความไม่แน่นอนในการประมาณน้ำหนัก

การคำนวณโมเมนต์ของความเฉื่อย

โมเมนต์ของความเฉื่อยจะแตกต่างกันไปตามรูปทรงหน้าตัดของคาน:

1. คานสี่เหลี่ยมผืนผ้า: $I = \frac{b \cdot h^3}{12}$ โดยที่ $b$ = ความกว้างและ $h$ = ความสูง

2. คานกลม: $I = \frac{\pi \cdot d^4}{64}$ โดยที่ $d$ = เส้นผ่านศูนย์กลาง

3. คาน I: $I = \frac{b \cdot h^3}{12} - \frac{(b - t_w) \cdot (h - 2t_f)^3}{12}$ โดยที่ $b$ = ความกว้างของฟลานจ์, $h$ = ความสูงทั้งหมด, $t_w$ = ความหนาของเว็บ, และ $t_f$ = ความหนาของฟลานจ์

วิธีการใช้แคลคูลเลเตอร์ความปลอดภัยของการรับน้ำหนักของคาน

แคลคูลเลเตอร์ของเราทำให้การคำนวณที่ซับซ้อนเหล่านี้กลายเป็นรูปแบบที่ใช้งานง่าย ทำตามขั้นตอนเหล่านี้เพื่อกำหนดว่าคานของคุณสามารถรองรับน้ำหนักที่ตั้งใจได้อย่างปลอดภัยหรือไม่:

ขั้นตอนที่ 1: เลือกประเภทคาน

เลือกจากประเภทหน้าตัดคานสามประเภทที่พบได้บ่อย:

• สี่เหลี่ยมผืนผ้า: พบได้บ่อยในการก่อสร้างไม้และการออกแบบเหล็กที่เรียบง่าย
• คาน I: ใช้ในแอปพลิเคชันโครงสร้างขนาดใหญ่เพื่อการกระจายวัสดุที่มีประสิทธิภาพ
• กลม: พบได้ในเสา เสา และแอปพลิเคชันเฉพาะบางอย่าง

ขั้นตอนที่ 2: เลือกวัสดุ

เลือกวัสดุของคาน:

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

ขั้นตอนที่ 3: ป้อนขนาดของคาน

ป้อนขนาดตามประเภทคานที่เลือก:

สำหรับคาน สี่เหลี่ยมผืนผ้า:

• ความกว้าง (m)
• ความสูง (m)

สำหรับ คาน I:

• ความสูง (m)
• ความกว้างของฟลานจ์ (m)
• ความหนาของฟลานจ์ (m)
• ความหนาของเว็บ (m)

สำหรับคาน กลม:

• เส้นผ่านศูนย์กลาง (m)

ขั้นตอนที่ 4: ป้อนความยาวของคานและน้ำหนักที่ใช้

• ความยาวของคาน (m): ระยะห่างระหว่างการรองรับ
• น้ำหนักที่ใช้ (N): แรงที่คานต้องรองรับ

ขั้นตอนที่ 5: ดูผลลัพธ์

หลังจากป้อนพารามิเตอร์ทั้งหมดแล้ว แคลคูลเลเตอร์จะแสดง:

• ผลลัพธ์ด้านความปลอดภัย: ว่าคานนั้นปลอดภัยหรือไม่ปลอดภัยสำหรับน้ำหนักที่กำหนด
• ปัจจัยความปลอดภัย: อัตราส่วนของน้ำหนักที่อนุญาตสูงสุดต่อน้ำหนักที่ใช้
• น้ำหนักที่อนุญาตสูงสุด: น้ำหนักสูงสุดที่คานสามารถรองรับได้อย่างปลอดภัย
• ความเครียดที่เกิดขึ้นจริง: ความเครียดที่เกิดจากน้ำหนักที่ใช้
• ความเครียดที่อนุญาต: ความเครียดสูงสุดที่วัสดุสามารถทนได้อย่างปลอดภัย

การแสดงภาพจะให้ภาพรวมของคานที่มีน้ำหนักที่ใช้และระบุว่าปลอดภัย (สีเขียว) หรือไม่ปลอดภัย (สีแดง)

คุณสมบัติของวัสดุที่ใช้ในการคำนวณ

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

ค่าดังกล่าวแสดงถึงความเครียดที่อนุญาตทั่วไปสำหรับการใช้งานทางโครงสร้าง สำหรับการใช้งานที่สำคัญ ควรปรึกษากฎการออกแบบเฉพาะวัสดุหรือวิศวกรโครงสร้าง

กรณีการใช้งานและแอปพลิเคชัน

การก่อสร้างและวิศวกรรมโครงสร้าง

แคลคูลเลเตอร์ความปลอดภัยของการรับน้ำหนักของคานมีค่าอย่างยิ่งสำหรับ:

1. การออกแบบเบื้องต้น: ประเมินตัวเลือกคานต่าง ๆ อย่างรวดเร็วในระหว่างขั้นตอนการออกแบบเบื้องต้น
2. การตรวจสอบ: ตรวจสอบว่าคานที่มีอยู่สามารถรองรับน้ำหนักเพิ่มเติมในระหว่างการปรับปรุง
3. การเลือกวัสดุ: เปรียบเทียบวัสดุต่าง ๆ เพื่อค้นหาวิธีการที่มีประสิทธิภาพที่สุด
4. วัตถุประสงค์ทางการศึกษา: สอนหลักการวิศวกรรมโครงสร้างด้วยการตอบสนองภาพที่ชัดเจน

การก่อสร้างที่อยู่อาศัย

เจ้าของบ้านและผู้รับเหมาอาจใช้แคลคูลเลเตอร์นี้สำหรับ:

1. การก่อสร้างระเบียง: ตรวจสอบให้แน่ใจว่าโครงสร้างรองรับน้ำหนักที่คาดการณ์ไว้ได้
2. การปรับปรุงห้องใต้ดิน: ตรวจสอบว่าคานที่มีอยู่สามารถรองรับการกำหนดค่าผนังใหม่ได้
3. การเปลี่ยนแปลงห้องใต้หลังคา: กำหนดว่าคานพื้นสามารถรองรับการเปลี่ยนแปลงการใช้งานได้หรือไม่
4. การซ่อมแซมหลังคา: ตรวจสอบว่าคานหลังคาสามารถรองรับวัสดุหลังคาใหม่ได้

โครงการ DIY

ผู้ที่ชื่นชอบ DIY จะพบว่าแคลคูลเลเตอร์นี้มีประโยชน์สำหรับ:

1. ชั้นวาง: ตรวจสอบให้แน่ใจว่าการรองรับชั้นสามารถรองรับน้ำหนักของหนังสือหรือของสะสมได้
2. โต๊ะทำงาน: ออกแบบโต๊ะทำงานที่แข็งแรงซึ่งจะไม่ยุบตัวภายใต้เครื่องมือหนัก
3. เฟอร์นิเจอร์: สร้างเฟอร์นิเจอร์ที่กำหนดเองด้วยการรองรับโครงสร้างที่เพียงพอ
4. โครงสร้างสวน: ออกแบบเพอร์โกล่า อาร์เบอร์ และเตียงยกที่มีอายุการใช้งานยาวนาน

แอปพลิเคชันในอุตสาหกรรม

ในสภาพแวดล้อมอุตสาหกรรม แคลคูลเลเตอร์นี้สามารถช่วยในการ:

1. การรองรับอุปกรณ์: ตรวจสอบว่าคานสามารถรองรับเครื่องจักรและอุปกรณ์ได้หรือไม่
2. โครงสร้างชั่วคราว: ออกแบบนั่งร้านและแพลตฟอร์มชั่วคราวอย่างปลอดภัย
3. การจัดการวัสดุ: ตรวจสอบว่าคานในชั้นเก็บสามารถรองรับน้ำหนักของสินค้าคงคลังได้
4. การวางแผนการบำรุงรักษา: ประเมินว่าภูมิทัศน์ที่มีอยู่สามารถรองรับน้ำหนักชั่วคราวในระหว่างการบำรุงรักษาได้หรือไม่

ทางเลือกแทนแคลคูลเลเตอร์ความปลอดภัยของการรับน้ำหนักของคาน

ในขณะที่แคลคูลเลเตอร์ของเราให้การประเมินความปลอดภัยของคานที่ตรงไปตรงมา แต่ก็มีวิธีการทางเลือกสำหรับสถานการณ์ที่ซับซ้อนมากขึ้น:

1. การวิเคราะห์องค์ประกอบจำกัด (FEA): สำหรับรูปทรงที่ซับซ้อน เงื่อนไขการโหลด หรือพฤติกรรมของวัสดุที่ไม่เป็นมาตรฐาน ซอฟต์แวร์ FEA จะให้การวิเคราะห์ความเครียดที่ละเอียดตลอดทั้งโครงสร้าง
2. ตารางรหัสอาคาร: รหัสอาคารหลายแห่งมีตารางช่วงที่คำนวณล่วงหน้าสำหรับขนาดคานทั่วไปและเงื่อนไขการโหลด ซึ่งทำให้ไม่จำเป็นต้องคำนวณเป็นรายบุคคล
3. ซอฟต์แวร์การวิเคราะห์โครงสร้าง: ซอฟต์แวร์วิศวกรรมโครงสร้างเฉพาะสามารถวิเคราะห์ระบบอาคารทั้งหมด โดยคำนึงถึงปฏิสัมพันธ์ระหว่างองค์ประกอบโครงสร้างต่าง ๆ
4. การปรึกษาวิศวกรโครงสร้าง: สำหรับแอปพลิเคชันที่สำคัญหรือโครงสร้างที่ซับซ้อน การปรึกษากับวิศวกรโครงสร้างที่ได้รับอนุญาตจะให้การรับประกันความปลอดภัยในระดับสูงสุด
5. การทดสอบน้ำหนักจริง: ในบางกรณี การทดสอบทางกายภาพของตัวอย่างคานอาจจำเป็นต้องยืนยันประสิทธิภาพ โดยเฉพาะสำหรับวัสดุหรือเงื่อนไขการโหลดที่ไม่เป็นมาตรฐาน

เลือกวิธีการที่ตรงกับความซับซ้อนของโครงการของคุณและผลกระทบจากการล้มเหลวที่อาจเกิดขึ้น

ประวัติของทฤษฎีคานและการวิเคราะห์โครงสร้าง

หลักการที่อยู่เบื้องหลังแคลคูลเลเตอร์ความปลอดภัยของการรับน้ำหนักของคานของเราได้พัฒนาขึ้นจากการพัฒนาทางวิทยาศาสตร์และวิศวกรรมในช่วงหลายศตวรรษ:

จุดเริ่มต้นในยุคโบราณ

ทฤษฎีคานมีรากฐานมาจากอารยธรรมโบราณ ชาวโรมัน ชาวอียิปต์ และชาวจีนล้วนพัฒนาวิธีการเชิงประจักษ์ในการกำหนดขนาดคานที่เหมาะสมสำหรับโครงสร้างของพวกเขา วิศวกรในยุคแรกเหล่านี้พึ่งพาประสบการณ์และการทดลองมากกว่าการวิเคราะห์ทางคณิตศาสตร์

การเกิดขึ้นของทฤษฎีคานสมัยใหม่

รากฐานทางคณิตศาสตร์ของทฤษฎีคานเริ่มต้นในศตวรรษที่ 17 และ 18:

• กาลิเลโอ กาลิเลอี (1638) ทำการวิเคราะห์ความแข็งแรงของคานอย่างเป็นวิทยาศาสตร์ครั้งแรก แม้ว่ารูปแบบของเขาจะไม่สมบูรณ์
• โรเบิร์ต ฮุก (1678) สร้างความสัมพันธ์ระหว่างแรงและการเปลี่ยนรูปด้วยกฎที่มีชื่อเสียงของเขา: "Ut tensio, sic vis" (เมื่อการขยายตัว ดังนั้น แรง)
• จาคอบ เบอร์นูลลี (1705) พัฒนาทฤษฎีของเส้นโค้งยืดหยุ่น โดยอธิบายว่าคานดัดตัวอย่างไรภายใต้การโหลด
• เลออนฮาร์ด ออยเลอร์ (1744) ขยายงานของเบอร์นูลลี สร้างทฤษฎีคานของออยเลอร์-เบอร์นูลลีที่ยังคงเป็นพื้นฐานในปัจจุบัน

การปฏิวัติอุตสาหกรรมและการมาตรฐาน

ศตวรรษที่ 19 มีการพัฒนาทฤษฎีคานและการประยุกต์ใช้อย่างรวดเร็ว:

• คลอด-หลุยส์ นาวิเยร์ (1826) รวมทฤษฎีก่อนหน้านี้เข้าเป็นแนวทางที่ครอบคลุมสำหรับการวิเคราะห์โครงสร้าง
• วิลเลียม แรนไคน์ (1858) เผยแพร่คู่มือเกี่ยวกับกลศาสตร์ที่กลายเป็นเอกสารอ้างอิงมาตรฐานสำหรับวิศวกร
• สตีเฟน ติโมเชนโก (ต้นศตวรรษที่ 20) ปรับปรุงทฤษฎีคานเพื่อคำนึงถึงการเปลี่ยนรูปเฉือนและโมเมนต์การหมุน

การพัฒนาในยุคปัจจุบัน

การวิเคราะห์โครงสร้างในปัจจุบันรวมทฤษฎีคานคลาสสิกเข้ากับวิธีการคอมพิวเตอร์ขั้นสูง:

• วิศวกรรมที่ใช้คอมพิวเตอร์ (1960s-present) ได้ปฏิวัติการวิเคราะห์โครงสร้าง โดยอนุญาตให้มีการจำลองที่ซับซ้อน
• รหัสและมาตรฐานการก่อสร้าง ได้พัฒนาขึ้นเพื่อให้แน่ใจว่ามีขอบเขตความปลอดภัยที่สอดคล้องกันในโครงการก่อสร้างต่าง ๆ
• วัสดุขั้นสูง เช่น คอมโพสิตความแข็งแรงสูง ได้ขยายความเป็นไปได้ในการออกแบบคานในขณะที่ต้องการวิธีการวิเคราะห์ใหม่

แคลคูลเลเตอร์ของเราสร้างขึ้นจากประวัติศาสตร์ที่อุดมไปด้วยนี้ ทำให้ความรู้ทางวิศวกรรมหลายศตวรรษสามารถเข้าถึงได้ผ่านส่วนติดต่อที่เรียบง่าย

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

ตัวอย่างที่ 1: คานพื้นในบ้าน

เจ้าของบ้านต้องการตรวจสอบว่าคานไม้พื้นสามารถรองรับอ่างอาบน้ำหนักมากใหม่ได้หรือไม่:

• ประเภทคาน: สี่เหลี่ยมผืนผ้า
• วัสดุ: ไม้
• ขนาด: 0.05 m (2") ความกว้าง × 0.2 m (8") ความสูง
• ความยาว: 3.5 m
• น้ำหนักที่ใช้: 2000 N (ประมาณ 450 lbs)

ผลลัพธ์: แคลคูลเลเตอร์แสดงว่าคานนี้ปลอดภัยโดยมีปัจจัยความปลอดภัย 1.75

ตัวอย่างที่ 2: คานเหล็กรองรับ

วิศวกรกำลังออกแบบคานรองรับสำหรับอาคารพาณิชย์ขนาดเล็ก:

• ประเภทคาน: คาน I
• วัสดุ: เหล็ก
• ขนาด: 0.2 m ความสูง, 0.1 m ความกว้างของฟลานจ์, 0.01 m ความหนาของฟลานจ์, 0.006 m ความหนาของเว็บ
• ความยาว: 5 m
• น้ำหนักที่ใช้: 50000 N (ประมาณ 11240 lbs)

ผลลัพธ์: แคลคูลเลเตอร์แสดงว่าคานนี้ปลอดภัยโดยมีปัจจัยความปลอดภัย 2.3

ตัวอย่างที่ 3: เสาอลูมิเนียม

ผู้ผลิตป้ายต้องการตรวจสอบว่าเสาอลูมิเนียมสามารถรองรับป้ายร้านค้าใหม่ได้หรือไม่:

• ประเภทคาน: กลม
• วัสดุ: อลูมิเนียม
• ขนาด: 0.08 m เส้นผ่านศูนย์กลาง
• ความยาว: 4 m
• น้ำหนักที่ใช้: 800 N (ประมาณ 180 lbs)

ผลลัพธ์: แคลคูลเลเตอร์แสดงว่าคานนี้ไม่ปลอดภัยโดยมีปัจจัยความปลอดภัย 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)}`);
41

1import 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}")
53

1public 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}
81

1' ฟังก์ชัน 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")
55

1#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 มีประสิทธิภาพโดยเฉพาะเพราะมันวางวัสดุมากขึ้นห่างจากแกนกลาง ซึ่งเพิ่มโมเมนต์ของความเฉื่อยและความสามารถในการรับน้ำหนักสำหรับวัสดุที่กำหนด

อ้างอิง

1. Gere, J. M., & Goodno, B. J. (2012). Mechanics of Materials (8th ed.). Cengage Learning.

2. Hibbeler, R. C. (2018). Structural Analysis (10th ed.). Pearson.

3. American Institute of Steel Construction. (2017). Steel Construction Manual (15th ed.). AISC.

4. American Wood Council. (2018). National Design Specification for Wood Construction. AWC.

5. Aluminum Association. (2020). Aluminum Design Manual. The Aluminum Association.

6. International Code Council. (2021). International Building Code. ICC.

7. Timoshenko, S. P., & Gere, J. M. (1972). Mechanics of Materials. Van Nostrand Reinhold Company.

8. Beer, F. P., Johnston, E. R., DeWolf, J. T., & Mazurek, D. F. (2020). Mechanics of Materials (8th ed.). McGraw-Hill Education.

ลองใช้แคลคูลเลเตอร์ความปลอดภัยของการรับน้ำหนักของคานของเราในวันนี้!

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

สำหรับความต้องการการวิเคราะห์โครงสร้างที่ซับซ้อนมากขึ้น ให้พิจารณาปรึกษาวิศวกรโครงสร้างมืออาชีพที่สามารถให้คำแนะนำที่เหมาะสมสำหรับแอปพลิเคชันเฉพาะของคุณ