બોલ્ટ છિદ્રોની સંખ્યા અને આસપાસના છિદ્રો વચ્ચેની અંતર આધારિત બોલ્ટ સર્કલનો વ્યાસ ગણો. મિકેનિકલ ઇજનેરી, ઉત્પાદન અને એસેમ્બલી એપ્લિકેશન્સ માટે આવશ્યક.
બોલ્ટ છિદ્રોની સંખ્યા અને તેમના વચ્ચેની અંતર પરથી બોલ્ટ સર્કલનો વ્યાસ ગણો.
બોલ્ટ સર્કલ વ્યાસ
0.00
બોલ્ટ સર્કલ વ્યાસ = છિદ્રો વચ્ચેનું અંતર / (2 * sin(π / છિદ્રોની સંખ્યા))
વ્યાસ = 10.00 / (2 * sin(π / 4)) = 0.00
બોલ્ટ સર્કલ વ્યાસ કેલ્ક્યુલેટર એક ચોક્કસ ઇજનેરી સાધન છે જે બોલ્ટ છિદ્રોની સંખ્યા અને સમાન છિદ્રો વચ્ચેની અંતર પરથી બોલ્ટ સર્કલનો વ્યાસ ચોકસાઈથી નક્કી કરવા માટે બનાવવામાં આવ્યું છે. બોલ્ટ સર્કલ (જેને બોલ્ટ પેટર્ન અથવા પિચ સર્કલ પણ કહેવામાં આવે છે) મિકેનિકલ ઇજનેરી, ઉત્પાદન અને બાંધકામમાં એક મહત્વપૂર્ણ માપ છે જે ફલાંજ, ચકરો અને મિકેનિકલ કાઉપલિંગ્સ જેવા ઘટકો પર બોલ્ટ છિદ્રોની વર્તુળાકાર વ્યવસ્થા વ્યાખ્યાયિત કરે છે. આ કેલ્ક્યુલેટર બોલ્ટેડ ઘટકોની યોગ્ય સંકલન અને ફિટ માટે જરૂરી ચોક્કસ વ્યાસ નક્કી કરવાની પ્રક્રિયાને સરળ બનાવે છે.
તમે ફલાંજ કનેક્શન ડિઝાઇન કરી રહ્યા હોવ, ઓટોમોટિવ ચક્રો પર કામ કરી રહ્યા હોવ, અથવા વર્તુળાકાર માઉન્ટિંગ પેટર્ન બનાવી રહ્યા હોવ, બોલ્ટ સર્કલ વ્યાસને સમજવું મહત્વપૂર્ણ છે જેથી ઘટકો યોગ્ય રીતે એકસાથે ફિટ થાય. અમારી કેલ્ક્યુલેટર ધોરણ ફોર્મ્યુલા ઉપયોગ કરીને તુરંત, ચોકસાઈથી પરિણામો આપે છે અને વધુ સારી સમજ માટે બોલ્ટ પેટર્નનું દૃશ્યમાન પ્રતિનિધિત્વ પ્રદાન કરે છે.
બોલ્ટ સર્કલ વ્યાસ (BCD) નીચેના ફોર્મ્યુલા દ્વારા ગણવામાં આવે છે:
જ્યાં:
આ ફોર્મ્યુલા કાર્ય કરે છે કારણ કે બોલ્ટ છિદ્રો વર્તુળની આસપાસ નિયમિત પૉલિગોન પેટર્નમાં વ્યવસ્થિત છે. સમાન છિદ્રો વચ્ચેનું અંતર વર્તુળનું એક કોર્ડ બનાવે છે, અને ફોર્મ્યુલા તમામ બોલ્ટ છિદ્રના કેન્દ્રો દ્વારા પસાર થતી વર્તુળનો વ્યાસ ગણવે છે.
ફોર્મ્યુલા નિયમિત પૉલિગોનના ગુણધર્મોથી ઉત્પન્ન થાય છે જે સર્કલમાં નોંધાયેલ છે:
n છિદ્રો અને સમાન છિદ્રો વચ્ચેના અંતર s સાથેના બોલ્ટ સર્કલ માટે, વ્યાસ આ રીતે s ÷ [2 × sin(π/n)] છે.
અમારા બૉલ્ટ સર્કલ વ્યાસ કેલ્ક્યુલેટરનો ઉપયોગ કરવો સરળ અને સ્વાભાવિક છે:
ચાલો 15 યુનિટ્સની અંતર સાથે 6-છિદ્ર પેટર્ન માટે બોલ્ટ સર્કલ વ્યાસ ગણીએ:
ગણવામાં આવેલ બોલ્ટ સર્કલ વ્યાસ તે વર્તુળનો વ્યાસ દર્શાવે છે જે દરેક બોલ્ટ છિદ્રના કેન્દ્રમાંથી પસાર થાય છે. આ માપ મહત્વપૂર્ણ છે:
બોલ્ટ સર્કલ વ્યાસની ગણતરી ઘણા ઇજનેરી અને ઉત્પાદન એપ્લિકેશન્સમાં મહત્વપૂર્ણ છે:
પાઇપ ફલાંજ કનેક્શન ડિઝાઇન કરતી વખતે:
ઓટોમોટિવ ચક્રોને બદલતી વખતે:
જ્યારે બોલ્ટ સર્કલ વ્યાસ વર્તુળાકાર બોલ્ટ પેટર્નને નિર્ધારિત કરવાનો ધોરણ પદ્ધતિ છે, ત્યારે અન્ય પદ્ધતિઓ છે:
પિચ સર્કલ વ્યાસ મૂળભૂત રીતે બોલ્ટ સર્કલ વ્યાસ સમાન છે પરંતુ ગિયર ટર્મિનોલોજીમાં વધુ સામાન્ય રીતે ઉપયોગમાં લેવાય છે. તે છિદ્રો અથવા બોલ્ટ છિદ્રોના કેન્દ્ર (અથવા પિચ પોઈન્ટ) દ્વારા પસાર થતી વર્તુળનો વ્યાસ દર્શાવે છે.
ઓટોમોટિવ એપ્લિકેશન્સમાં, બોલ્ટ પેટર્ન સામાન્ય રીતે સંક્ષિપ્ત નોંધણીનો ઉપયોગ કરીને નિર્ધારિત કરવામાં આવે છે:
કેટલાક એપ્લિકેશન્સ માટે, ખાસ કરીને ઓછા બોલ્ટ છિદ્રો સાથે, સીધી માપણીનો ઉપયોગ થઈ શકે છે:
આધુનિક ડિઝાઇન ઘણીવાર કમ્પ્યુટર-સહાયિત ડિઝાઇન (CAD) નો ઉપયોગ કરીને છિદ્રોનું સ્થાન સીધું નિર્ધારિત કરે છે:
બોલ્ટ સર્કલનો વિચાર મિકેનિકલ ઇજનેરીમાં ઔદ્યોગિક ક્રાંતિથી જરુરી રહ્યો છે. તેની મહત્વતાને ધોરણિત ઉત્પાદન પ્રક્રિયાઓના વિકાસ સાથે વધારવામાં આવ્યું:
અહીં વિવિધ પ્રોગ્રામિંગ ભાષાઓમાં બોલ્ટ સર્કલ વ્યાસ ફોર્મ્યુલાની અમલવારી છે:
1function calculateBoltCircleDiameter(numberOfHoles, distanceBetweenHoles) {
2 if (numberOfHoles < 3) {
3 throw new Error("Number of holes must be at least 3");
4 }
5 if (distanceBetweenHoles <= 0) {
6 throw new Error("Distance between holes must be positive");
7 }
8
9 const angleInRadians = Math.PI / numberOfHoles;
10 const boltCircleDiameter = distanceBetweenHoles / (2 * Math.sin(angleInRadians));
11
12 return boltCircleDiameter;
13}
14
15// Example usage:
16const holes = 6;
17const distance = 15;
18const diameter = calculateBoltCircleDiameter(holes, distance);
19console.log(`Bolt Circle Diameter: ${diameter.toFixed(2)}`);
201import math
2
3def calculate_bolt_circle_diameter(number_of_holes, distance_between_holes):
4 """
5 Calculate the bolt circle diameter based on number of holes and distance between them.
6
7 Args:
8 number_of_holes: Integer number of holes (minimum 3)
9 distance_between_holes: Positive number representing distance between adjacent holes
10
11 Returns:
12 The calculated bolt circle diameter
13 """
14 if number_of_holes < 3:
15 raise ValueError("Number of holes must be at least 3")
16 if distance_between_holes <= 0:
17 raise ValueError("Distance between holes must be positive")
18
19 angle_in_radians = math.pi / number_of_holes
20 bolt_circle_diameter = distance_between_holes / (2 * math.sin(angle_in_radians))
21
22 return bolt_circle_diameter
23
24# Example usage:
25holes = 6
26distance = 15
27diameter = calculate_bolt_circle_diameter(holes, distance)
28print(f"Bolt Circle Diameter: {diameter:.2f}")
291public class BoltCircleCalculator {
2 /**
3 * Calculates the bolt circle diameter based on number of holes and distance between them.
4 *
5 * @param numberOfHoles The number of bolt holes (minimum 3)
6 * @param distanceBetweenHoles The distance between adjacent holes (positive value)
7 * @return The calculated bolt circle diameter
8 * @throws IllegalArgumentException if inputs are invalid
9 */
10 public static double calculateBoltCircleDiameter(int numberOfHoles, double distanceBetweenHoles) {
11 if (numberOfHoles < 3) {
12 throw new IllegalArgumentException("Number of holes must be at least 3");
13 }
14 if (distanceBetweenHoles <= 0) {
15 throw new IllegalArgumentException("Distance between holes must be positive");
16 }
17
18 double angleInRadians = Math.PI / numberOfHoles;
19 double boltCircleDiameter = distanceBetweenHoles / (2 * Math.sin(angleInRadians));
20
21 return boltCircleDiameter;
22 }
23
24 public static void main(String[] args) {
25 int holes = 6;
26 double distance = 15.0;
27 double diameter = calculateBoltCircleDiameter(holes, distance);
28 System.out.printf("Bolt Circle Diameter: %.2f%n", diameter);
29 }
30}
311#include <iostream>
2#include <cmath>
3#include <stdexcept>
4
5/**
6 * Calculates the bolt circle diameter based on number of holes and distance between them.
7 *
8 * @param numberOfHoles The number of bolt holes (minimum 3)
9 * @param distanceBetweenHoles The distance between adjacent holes (positive value)
10 * @return The calculated bolt circle diameter
11 * @throws std::invalid_argument if inputs are invalid
12 */
13double calculateBoltCircleDiameter(int numberOfHoles, double distanceBetweenHoles) {
14 if (numberOfHoles < 3) {
15 throw std::invalid_argument("Number of holes must be at least 3");
16 }
17 if (distanceBetweenHoles <= 0) {
18 throw std::invalid_argument("Distance between holes must be positive");
19 }
20
21 double angleInRadians = M_PI / numberOfHoles;
22 double boltCircleDiameter = distanceBetweenHoles / (2 * sin(angleInRadians));
23
24 return boltCircleDiameter;
25}
26
27int main() {
28 try {
29 int holes = 6;
30 double distance = 15.0;
31 double diameter = calculateBoltCircleDiameter(holes, distance);
32 printf("Bolt Circle Diameter: %.2f\n", diameter);
33 } catch (const std::exception& e) {
34 std::cerr << "Error: " << e.what() << std::endl;
35 return 1;
36 }
37 return 0;
38}
391' Excel formula for bolt circle diameter
2=distance_between_holes/(2*SIN(PI()/number_of_holes))
3
4' Excel VBA function
5Function BoltCircleDiameter(numberOfHoles As Integer, distanceBetweenHoles As Double) As Double
6 If numberOfHoles < 3 Then
7 Err.Raise 5, "BoltCircleDiameter", "Number of holes must be at least 3"
8 End If
9
10 If distanceBetweenHoles <= 0 Then
11 Err.Raise 5, "BoltCircleDiameter", "Distance between holes must be positive"
12 End If
13
14 Dim angleInRadians As Double
15 angleInRadians = WorksheetFunction.Pi() / numberOfHoles
16
17 BoltCircleDiameter = distanceBetweenHoles / (2 * Sin(angleInRadians))
18End Function
191using System;
2
3public class BoltCircleCalculator
4{
5 /// <summary>
6 /// Calculates the bolt circle diameter based on number of holes and distance between them.
7 /// </summary>
8 /// <param name="numberOfHoles">The number of bolt holes (minimum 3)</param>
9 /// <param name="distanceBetweenHoles">The distance between adjacent holes (positive value)</param>
10 /// <returns>The calculated bolt circle diameter</returns>
11 /// <exception cref="ArgumentException">Thrown when inputs are invalid</exception>
12 public static double CalculateBoltCircleDiameter(int numberOfHoles, double distanceBetweenHoles)
13 {
14 if (numberOfHoles < 3)
15 {
16 throw new ArgumentException("Number of holes must be at least 3", nameof(numberOfHoles));
17 }
18
19 if (distanceBetweenHoles <= 0)
20 {
21 throw new ArgumentException("Distance between holes must be positive", nameof(distanceBetweenHoles));
22 }
23
24 double angleInRadians = Math.PI / numberOfHoles;
25 double boltCircleDiameter = distanceBetweenHoles / (2 * Math.Sin(angleInRadians));
26
27 return boltCircleDiameter;
28 }
29
30 public static void Main()
31 {
32 int holes = 6;
33 double distance = 15.0;
34 double diameter = CalculateBoltCircleDiameter(holes, distance);
35 Console.WriteLine($"Bolt Circle Diameter: {diameter:F2}");
36 }
37}
38બોલ્ટ સર્કલ વ્યાસ (BCD) એ એક કલ્પિત વર્તુળનો વ્યાસ છે જે બોલ્ટ પેટર્નમાં દરેક બોલ્ટ છિદ્રના કેન્દ્રમાંથી પસાર થાય છે. તે ઘટકો વચ્ચે યોગ્ય સંકલન અને ફિટ સુનિશ્ચિત કરવા માટે એક મહત્વપૂર્ણ માપ છે.
બોલ્ટ સર્કલ વ્યાસને નીચેના ફોર્મ્યુલાનો ઉપયોગ કરીને ગણવામાં આવે છે: BCD = સમાન છિદ્રો વચ્ચેનું અંતર ÷ [2 × sin(π ÷ છિદ્રોની સંખ્યા)]. આ ફોર્મ્યુલા સમાન છિદ્રો વચ્ચેના સીધા અંતરને તમામ બોલ્ટ છિદ્રના કેન્દ્રો દ્વારા પસાર થતી વર્તુળના વ્યાસ સાથે સંબંધિત કરે છે.
અનન્ય વર્તુળને વ્યાખ્યાયિત કરવા માટે ઓછામાં ઓછા 3 બોલ્ટ છિદ્રો જરૂરી છે. 3 પોઈન્ટ્સ કરતાં ઓછા સાથે, તમે ગણિતીય રીતે અનન્ય વર્તુળને વ્યાખ્યાયિત કરી શકતા નથી.
હા, આ કેલ્ક્યુલેટર ઓટોમોટિવ એપ્લિકેશન્સ માટે સંપૂર્ણ છે. ઉદાહરણ તરીકે, જો તમે જાણો છો કે તમારા ચક્રમાં 5 લોગ્સ છે અને સમાન લોગ્સ વચ્ચેનું અંતર 70 મીમી છે, તો તમે બોલ્ટ સર્કલ વ્યાસની ગણતરી કરી શકો છો (જે લગભગ 114.3 મીમી હશે, 5×114.3 મીમીનું સામાન્ય પેટર્ન).
કાર્યક્ષમ રીતે, તે એક જ માપ છે—છિદ્રો અથવા ફીચર્સના કેન્દ્રો દ્વારા પસાર થતી વર્તુળનો વ્યાસ. "બોલ્ટ સર્કલ વ્યાસ" સામાન્ય રીતે બોલ્ટ પેટર્ન માટે ઉપયોગમાં લેવાય છે, જ્યારે "પિચ સર્કલ વ્યાસ" વધુ સામાન્ય રીતે ગિયર ટર્મિનોલોજીમાં ઉપયોગમાં લેવાય છે.
ચોકસાઈ મહત્વપૂર્ણ છે, ખાસ કરીને જ્યારે છિદ્રોની સંખ્યા વધે છે. નાની માપની ભૂલો પણ ગણવામાં આવેલા બોલ્ટ સર્કલ વ્યાસને મહત્વપૂર્ણ રીતે અસર કરી શકે છે. ચોકસાઈવાળા એપ્લિકેશન્સ માટે, વિવિધ સમાન છિદ્રો વચ્ચેના અંતરોને માપો અને પરિણામોને સરેરાશ કરો.
નહીં, આ કેલ્ક્યુલેટર ચોક્કસપણે સમાન રીતે જગ્યા ધરાવતા બોલ્ટ પેટર્ન માટે ડિઝાઇન કરવામાં આવ્યું છે. અસમાન રીતે જગ્યા ધરાવતા પેટર્ન માટે, તમને વધુ જટિલ ગણતરીઓ અથવા સીધી માપણી પદ્ધતિઓની જરૂર પડશે.
શ્રેષ્ઠ પરિણામો માટે, કાલિપર્સ જેવી ચોકસાઈ માપન સાધનોનો ઉપયોગ કરીને એક બોલ્ટ છિદ્રમાંથી બીજા સમાન બોલ્ટ છિદ્રના કેન્દ્ર સુધી માપો. વિવિધ સમાન બિંદુઓ વચ્ચે અનેક માપો લો અને માપની ભૂલને ઘટાડવા માટે પરિણામોને સરેરાશ કરો.
કેલ્ક્યુલેટર કોઈપણ સંગ્રહિત એકમ પ્રણાલીમાં કાર્ય કરે છે. જો તમે સમાન છિદ્રો વચ્ચેનું અંતર મીમીમાં દાખલ કરો છો, તો બોલ્ટ સર્કલ વ્યાસ પણ મીમીમાં હશે. સમાન રીતે, જો તમે ઇંચનો ઉપયોગ કરો છો, તો પરિણામ પણ ઇંચમાં હશે.
n છિદ્રો ધરાવતા બોલ્ટ પેટર્ન માટે, સંબંધ છે: કેન્દ્ર-થી-કેન્દ્ર અંતર = 2 × બોલ્ટ સર્કલ વ્યાસ × sin(π/n), જ્યાં બોલ્ટ સર્કલ વ્યાસ બોલ્ટ સર્કલ વ્યાસનો અર્ધા છે.
ઓબર્ગ, ઇ., જોન્સ, એફ. ડી., હોર્ટેન, એચ. એલ., & રિફેલ, એચ. એચ. (2016). મશીનરીની હેન્ડબુક (30મું આવૃત્તિ). ઇન્ડસ્ટ્રિયલ પ્રેસ.
શિગ્લી, જે. ઇ., & મિશ્કે, સી. આર. (2001). મિકેનિકલ ઇજનેરી ડિઝાઇન (6 મી આવૃત્તિ). મકગ્રો-હિલ.
અમેરિકન નેશનલ સ્ટાન્ડર્ડ્સ ઇન્સ્ટિટ્યૂટ. (2013). ASME B16.5: પાઇપ ફલાંજ અને ફલાંજ ફિટિંગ્સ. ASME આંતરરાષ્ટ્રીય.
આંતરરાષ્ટ્રીય સંસ્થાનિકીકરણ માટેના સંસ્થાનો. (2010). ISO 7005: પાઇપ ફલાંજ - ભાગ 1: સ્ટીલ ફલાંજ. ISO.
ઓટોમોટિવ એન્જિનિયર્સ સોસાયટી. (2015). SAE J1926: બોલ્ટ સર્કલ પેટર્ન માટેનું માપ. SAE આંતરરાષ્ટ્રીય.
ડોઇટ્સches ઇનસ્ટિટ્યૂટ ફોર નોર્મિંગ. (2017). DIN EN 1092-1: ફલાંજ અને તેમના જોડાણો. વર્તુળાકાર ફલાંજ પાઇપ, વાલ્વ, ફિટિંગ્સ અને ઍક્સેસરીઝ માટે, PN નિર્ધારિત. DIN.
અમારા બોલ્ટ સર્કલ વ્યાસ કેલ્ક્યુલેટરને ઉપયોગ કરીને તમારા બોલ્ટ સર્કલ પેટર્નનો વ્યાસ ઝડપથી અને ચોકસાઈથી નક્કી કરો. ફક્ત બોલ્ટ છિદ્રોની સંખ્યા અને સમાન છિદ્રો વચ્ચેનું અંતર દાખલ કરો અને તમારા ઇજનેરી, ઉત્પાદન, અથવા DIY પ્રોજેક્ટ માટે ચોકસાઈથી પરિણામો મેળવો.
તમારા વર્કફ્લો માટે ઉપયોગી થવાના વધુ સાધનો શોધો