Sheet Metal Handout (HTML)

Autodesk University Course Handouts

Sheet Metal Flat Development with AutoCAD

MEC-T3-2
Tuesday
12:45 - 2:15 PM
Philadelphia PA
15 September 1998        

Owen Wengerd
ManuSoft
Fredericksburg, Ohio
PO Box 84   OH 44627
www.manusoft.com



Before harnessing the power of AutoCAD to aid in flat development, it's necessary to understand how sheet metal unfolding is done. This class will focus on defining terms and formulas, specific techniques for calculating bend allowances, and examples of difficult parts and how to tackle them. Several simple AutoLISP routines will help attendees use AutoCAD to make the task faster and more accurate. Novices will come away with the tools they need to perform basic flat development, and experts will learn new ways of doing old calculations with a unique system of formulas and charts.


INTRODUCTION

What is sheet metal fabrication?

There can be some ambiguity in terminology, but "sheet metal fabrication" in this context refers to manufacturing products out of sheet metal in a machine shop environment. This is usually done with sheet metal ranging from several thousandths of an inch up to about 3/8" thick, holding relatively tight tolerances throughout the manufacturing process.

There are several industry-specific terms which need to be explained for those unfamiliar with the lingo. Braking means bending a piece of sheet metal. This is typically done with a machine called a brake. A bent piece of sheet metal is said to be "broke".

A blank is a flat piece of sheet metal from which a sheet-metal part will be produced. In some cases, a single blank produces many parts; however, a blank is generally assumed to have been sheared to some predetermined size, usually referred to as the blank size.

What is Flat Development?

Flat development is the procedure whereby a bent sheet-metal part is mathematically unfolded into its flat (pre-bent) form. The idea is to define the size and shape of a flat piece of sheet metal which, when broke, matches specified dimensions.

The process of flat development may be different depending on the manufacturing method or the desired dimensional tolerance of the finished product. In some cases a flat template may be created which shows the developed part with features such as holes and bend lines at the correct locations. A bent part cannot be physically unfolded back to its exact original size due to permanent deformation of the metal which occurs during the braking process; therefore, the process of flat development always involves some type of calculation.

Why Is Flat Development Important?

Since a typical sheet-metal part requires several operations (such as shearing to size, punching holes, applying hardware, etc.) before the braking operation, there needs to be a way to consistently predict what size the flat part needs to be, without relying on trial-and-error. If that prediction is inaccurate, all the pre-braking operations are at risk of being wasted if the flat parts cannot be broke to specifications.

An accurate, consistent, system of flat development is therefore essential to any manufacturing operation which intends to produce sheet-metal parts.

The Purpose Of This Paper

This paper is not intended to be a course on flat development; rather, it's a compendium of important terms which are covered in the full presentation on this topic. The figures and tables should be useful to anyone who wishes to utilize the terminology and methods described. The full presentation covers additional topics related to sheet metal flat development, including specific examples, and other issues related to the task of flat development in a manufacturing environment.


DEFINING A SHEET-METAL BEND

Flat Development Terminology There are no standards which define the terminology used in flat development, so most people either develop their own or copy from somebody else. For the purpose of this presentation, a few general-purpose phrases and abbreviations will be used to refer to common elements of sheet metal bends. Some of the terminology may be familiar; most of it probably won't be. Nevertheless, these phrases and abbreviations will help define a framework with which we can communicate.


The Basic Parameters

The most basic information about a bend includes the bend radius, the bend angle, and the metal thickness (see Figure 1). These are the basic parameters which define a given bend for purposes of calculating a flat development.

It is also useful to refer to the Inside or Outside of a bend. In the context of flat development, the "inside" of a bend is always the side of the sheet metal with the smaller radius. It's important to understand that the inside or outside of a bend is completely independent of the inside or outside of the part that contains it. In practical terms, the inside is the side where the "punch" part of the brake tool is used, while the outside of the bend is on the "die" side. The inside of two bends on the same part may be on opposite surfaces of the sheet metal.

The bend radius is usually specified as the radius of the inside of the bend. To avoid confusion, we will use IBR to represent the "Inside Bend Radius" and OBR to represent the "Outside Bend Radius". The IBR will usually be the same radius as the brake tool used to make the bend.

In Figure 1, TH represents the metal thickness, and BA is the bend angle. Note that the bend angle can be viewed either as the angle of the bend arc, or as the angle through which the flat sheet is bent (the values are always identical, but the former is more useful from a mathematical standpoint while the latter is more useful from a practical standpoint).


Bend-Specific Terms Defined

Here are several additional phrases that will be used throughout this presentation:


APPLYING THE K-FACTOR METHOD

The "k-Factor" Method

This is the most common method for calculating bend allowances. The "k-Factor" method is based on the theory that somewhere between the inside bend arc and the outside bend arc is a layer of metal that gets neither stretched or compressed during bending. It also assumes that this layer remains at a constant radius around the bend. The radius of this "static" layer of metal is called the Neutral Bend Arc Radius, and is defined as the inside bend radius (IBR) plus a percentage (or k-factor) of the metal thickness.

The k in the formula above is constant for a specific material. For most types of steel it is close to 0.40 (or 40%). In any case, once the NBAR has been calculated, it's possible to calculate the developed length of the bend by calculating the length of the neutral bend arc.


Coining Some Useful Terms

In order to make the math more compact, it will be helpful to define some abbreviations for various elements of a bend (see Figure 2 for a graphic representation):


Deriving The Mathematical Equations

The "meat" of flat development is usually considered to be the process of calculating a Bend Allowance. There are actually several different values that may be thought of as bend allowances. Each value is typically calculated for a given bend, then used in some manner to "unfold" the bend. Here's a brief summary:

To understand the different types of bend allowances values, we'll take a look at an example which uses the IBA to calculate the developed dimensions of a simple 90° angle (see Figure 3). Using the formula in Table 1, IBA = -0.11504"; therefore we total all the inside dimensions (2.0" + 2.0" = 4.0"), then add the IBA (4.0" + -0.11504" = 3.88496").

As the developed view in Figure 3 shows, the IBA represents the distance between the edges of two imaginary surfaces which correspond to the associated inside surfaces of the sheet metal. This number is negative if the two "surfaces" overlap, as is the case in the example. Given the Inside Dimensions (that is, dimensions to the ITI), it is easy to calculate the developed length of the part once the IBA is known: simply add the inside dimensions together, then add the IBA to that total.



Figure 3: The relationship between the ITI, the IBA, and the developed length

Table 1 contains a list of abbreviations, and most of the common equations used to calculate bend allowances. The chart of equations shows separate equations for 90° bends. Since a majority of sheet-metal parts contain mostly 90° bends, and since the equations are simpler in those cases, it makes sense to use the simplified versions of the equations when possible.

There are special cases of sheet metal bends which are not covered here. Some notable examples include dutch bends and offset brakes, each of which requires special calculations. These are covered in more detail in the full presentation.



BEND ALLOWANCE CALCULATION CHART

*Note BA (Bend Angle), TH (Thickness) and k (eg 0.4 for mild steel) are data. All the rest are calculated.

BABend Angle (in degrees) NBAR  Neutral Bend Arc Radius
DBLDeveloped Bend Length OBAOutside Bend Allowance
IBAInside Bend Allowance OBLOOutside Bend Line Offset
IBLO  Inside Bend Line Offset OBROutside Bend Radius
ITIInside Theoretical Intersection OTIOutside Theoretical Intersection
kk-factor (usually 0.4 for mild steel)     THMetal Thickness

Additional Definitions

IBR   Inside Bend Radius (often just BR) and is where the "punch part of the brake tool fits.
         (The outside is in contact with the die when the sheetmetal is being broken (ie bent).

pi       180 deg expressed in radians (pi=3.4159 to 4 decimal places).

DBL   Developed Bend Length is the arc length of the neutral axis ie "length=br+(k*th)*ba" (cf s=rA).

(Note: A rule of thumb for low carbon steel "material offset" or "k-factor" is .33 for bends less than material thickness (t), .40 for bends t to 2-3t, and .5 for bends greater than 3t or rolling. Multiply by Pi/2 to convert to Pro E's own &qu0t;Y-factor&qu0t;. I've had success with Aluminum using the same numbers. -aj)

     


QTYANY ANGLE BEND90° BEND
NBAR  = k * TH + IBR  = k * TH + IBR
DBL  = NBAR * BA * pi/180  = NBAR * pi/2
  = (k * TH + IBR) * BA * pi/180 = (k * TH + IBR) * pi/2
IBLO  = IBR * tan(BA/2)  = IBR
OBLO  = OBR * tan(BA/2)  = OBR
IBA  = DBL - (2 * IBLO)  = DBL - (2 * IBR)
  = (k * TH + IBR) * BA * pi/180 - (2 * IBLO)  = (k * TH + IBR) * BA * pi/2 - (2 * IBR)
OBA  = DBL - (2 * OBLO)  = DBL - (2 * OBR)
  = (k * TH + IBR) * BA * pi/180 - (2 * OBLO)  = (k * TH + IBR) * BA * pi/180 - (2 * OBR)


Steps To Develop A Bend
1. Calculate the NBAR.
2. Calculate one of:
      a) IBA if mostly inside dimensions are known
      b) OBA if mostly outside dimensions are known
      c) DBL if mostly dimensions to tangents are known
3. If any dimensions need to be calculated, do so.
4. Total all the dimensions, then add the associated bend allowance(s) (IBA, OBA, or DBL).


USING AUTOCAD TO DO THE WORK

Calculating A Developed Dimension From A Cross-Section
Since bend allowance calculations are often done while working on a drawing in AutoCAD, it makes sense to use the capabilities of AutoCAD to make things easier. By selecting arcs and lines from a cross-section of a sheet-metal part with multiple bends, BDEV.LSP in Listing 1 makes it easy to calculate the overall developed length across the bends.

;Listing 1 (BDEV.LSP)

 
; BDEV Bend Developer [Version 2.2, 9/10/98]
;
; Copyright 1996 - 1998 ManuSoft
;
; ***************************************
; ****  Author:  Owen Wengerd        ****
; ****                               ****
; ****  ManuSoft                     ****
; ****  P.O. Box 84                  ****
; ****  Fredericksburg, OH  44627    ****
; ****  330-695-5903 (Voice)         ****
; ****  330-695-5903 (Fax)           ****
; ****  owenw@manusoft.com           ****
; ***************************************
;
; Bend Development Tool
;   Uses the k-factor method with the
;   specified k-factor and metal thickness
;   to calculate the developed length of
;   a part by selecting the lines and
;   arcs from a cross-section of the part.


;Declare Global Variables
;*BA       ;Bend angle (in degrees)
;*IBR      ;Inside bend radius
;*KF       ;k-Factor
;*TH       ;Metal thickness

;Define the application
(defun C:BDEV
  (/

  ;Declare Local Variables
  devlen   ;Total developed length
  entl     ;Entity dxf list
  inp      ;Result of (getkword)
  olderr   ;Original error handler
  sel      ;Result of (entget)

  ;Declare Local Functions
  adddev   ;Add and display developed length
  dxf      ;Extract dxf code
  errexit  ;Error handler
  numchk   ;Validate number
  numinp   ;Input valid number
  )

 
  ;Define Local Functions

  ;============================================
  ;= (adddev )                 =
  ;=   adds  to 'devlen' and   =
  ;=   prints the new total.                  =
  ;============================================
  (defun adddev (addlen)
    (princ
      (strcat
        "\nTotal developed length is "
        (rtos
          (setq devlen (+ devlen addlen))
          (getvar "LUNITS")
          (+ 2 (getvar "LUPREC"))))))

  ;============================================
  ;= (dxf  )           =
  ;=   extracts the value of the    =
  ;=   group from .              =
  ;============================================
  (defun dxf (grp elist)
    (cdr (assoc grp elist)))

  ;============================================
  ;= (errexit )                      =
  ;=   processes error .             =
  ;============================================
  (defun errexit (s)
    (setq *error* olderr)
    (if (and *error* (listp *error*))
      (*error* s)
      (if
        (not
          (member s
            '("console break"
              "Function cancelled"
              "quit / exit abort")))
	      (princ (strcat "\nError:  " s))))
    (princ))

  ;============================================
  ;= (numchk )                        =
  ;=   returns T if  is a positive    =
  ;=   number or zero.                        =
  ;============================================
  (defun numchk (num)
    (and (numberp num) (>= num 0)))

;Continued…

;…Listing 1 (BDEV.LSP) Continued

  ;============================================
  ;= (numinp  )              =
  ;=   gets input and validates it with       =
  ;=   (numchk) before returning it.          =
  ;============================================
  (defun numinp (prompt default / inp)
    (while
      (and
        (setq inp
          (getdist
            (strcat
              "\n"
              prompt
              "<"
              (rtos
                default
                (getvar "LUNITS")
                (+ 2 (getvar "LUPREC")))
              ">: ")))
        (not (numchk inp))))
    (cond (inp) (default)))


  ;********************************************
  ;*              Main Program                *
  ;********************************************

  ;set up our error handler
  (setq olderr *error* *error* errexit)

  ;check global variables for valid values
  ;and set to defaults if necessary
  (if (not (numchk *TH))
    (setq *TH 0.0598))

  ;get input and store in global variables
  (setq *TH
        (numinp "Material Thickness" *TH)
        *KF ;set k-Factor to 40%
        0.40)    ;[or, could use (numinp)]

   
;reset the running blank length total
  (setq devlen 0)

  ;loop until the user is finished selecting
  (while
    (or
      (setq sel (entsel "\nPick a segment: "))
      (/= (getvar "ERRNO") 52))
    (cond
      ( (not sel)
        (princ "  "))
      ( (= "LINE"
          (dxf 0
            (setq entl (entget (car sel)))))
        (adddev
          (distance
            (dxf 10 entl)
            (dxf 11 entl))))
      ( (= "ARC" (dxf 0 entl))
        (initget "Inside Outside")
        (setq inp
          (getkword
            (strcat
              "\nIs this arc ("
              "/Outside"
              ")?  ")))
        (setq *IBR
          (if (= inp "Outside")
            (- (dxf 40 entl) *TH)
            (dxf 40 entl)))
        (setq *BA
          (- (dxf 51 entl) (dxf 50 entl)))
        (if (< *BA 0)
          (setq *BA (+ *BA (* pi 2))))
        (adddev (* *BA (+ *IBR (* *KF *TH))))
        (setq *BA (/ (* *BA 180) pi)))
      ( (princ
          (strcat
            "  "
            "\nYou must select "
            "an ARC or LINE entity.")))))
   (princ))
;End-of-file 

Using AutoLISP To Solve Flat Development Calculations

Listing 2 shows BCAL.LSP, an AutoLISP-based calculator which can be invoked directly from the AutoCAD 'Command:' prompt or with a menu pick.
Since BCAL.LSP can be invoked transparently, it can feed the result of the calculation directly back to the prompt from which it was invoked. This is useful with the OFFSET command, for example, when you want to offset one bend edge line the correct distance to create the opposite bend edge line. Another benefit of transparent use of BCAL.LSP is that there is no loss of precision due to rounding (or typos).

;Listing 2 (BCAL.LSP)

; BCAL.LSP Bend Calculator [Version 2.2, 9/10/98]
;
; Copyright 1996 - 1998 ManuSoft
;
; ***************************************
; ****  Author:  Owen Wengerd        ****
; ****                               ****
; ****  ManuSoft                     ****
; ****  P.O. Box 84                  ****
; ****  Fredericksburg, OH  44627    ****
; ****  330-695-5903 (Voice)         ****
; ****  330-695-5903 (Fax)           ****
; ****  owenw@manusoft.com           ****
; ***************************************
;
; Bend Calculator
;   Calculates some common bend-allowance
;   related quantities from specific bend
;   properties.  If invoked transparently
;   the result is returned directly to an
;   AutoCAD command (such as OFFSET).


;Declare Global Variables
;*BA       ;Bend angle (in degrees)
;*IBR      ;Inside bend radius
;*KF       ;k-Factor
;*TH       ;Metal thickness

;Define the application
(defun C:BCAL
  (/

  ;Declare Local Variables
  IO       ;Inside bend line offset
  olderr   ;Original error handler
  OO       ;Outside bend line offset
  ret      ;result of (getkword)

  ;Declare Local Functions
  angchk   ;Validate angle
  anginp   ;Input valid angle
  dtr      ;Convert degrees to radians
  errexit  ;Error handler
  numchk   ;Validate number
  numinp   ;Input valid number
  tan      ;Tangent
  )

 
  ;Define Local Functions

  ;============================================
  ;= (angchk )                         =
  ;=   returns T if  is a valid angle  =
  ;=   in degrees, 'nil' otherwise.           =
  ;============================================
  (defun angchk (ang)
    (and
      (numberp ang)
      (> ang 0)
      (<= ang 360)))

  ;============================================
  ;= (anginp  )              =
  ;=   gets input and validates it with       =
  ;=   (angchk) before returning it.          =
  ;============================================
  (defun anginp (prompt default / inp)
    (while
      (and
        (setq inp
          (getangle
            (strcat
              "\n"
              prompt
              "<"
              (angtos
                (dtr default)
                (getvar "AUNITS")
                (+ 2 (getvar "AUPREC")))
              ">: ")))
        (not
          (angchk
            (setq inp (/ (* inp 180) pi)))))) (cond (inp) (default)))

  ;============================================
  ;= (dtr )                            =
  ;=   converts  from degrees to       =
  ;=   radians.                               =
  ;============================================
  (defun dtr (ang) (/ (* ang pi) 180.0))

;Continued…

;…Listing 2 (BCAL.LSP)Continued

  ;============================================
  ;= (errexit )                      =
  ;=   processes error .             =
  ;============================================
  (defun errexit (s)
	  (setq *error* olderr)
	 	(if (and *error* (listp *error*))
	    (*error* s)
	    (if
        (not
          (member s
            '("console break"
              "Function cancelled"
              "quit / exit abort")))
	      (princ (strcat "\nError:  " s))))
    (princ))

  ;============================================
  ;= (numchk )                        =
  ;=   returns T if  is a positive    =
  ;=   number or zero.                        =
  ;============================================
  (defun numchk (num)
    (and (numberp num) (>= num 0)))

  ;============================================
  ;= (numinp  )              =
  ;=   gets input and validates it with       =
  ;=   (numchk) before returning it.          =
  ;============================================
  (defun numinp (prompt default / inp)
    (while
      (and
        (setq inp
          (getdist
            (strcat
              "\n"
              prompt
              "<"
              (rtos
                default
                (getvar "LUNITS")
                (+ 2 (getvar "LUPREC")))
              ">: ")))
        (not (numchk inp))))
    (cond (inp) (default)))

  ;============================================
  ;= (tan )                            =
  ;=   returns the tangent of  (angle  =
  ;=   is in radians).                        =
  ;============================================
  (defun tan (ang) (/ (sin ang) (cos ang)))


 
  ;********************************************
  ;*              Main Program                *
  ;********************************************

  ;set up our error handler
  (setq olderr *error* *error* errexit)

  ;check global variables for valid values
  ;and set to defaults if necessary
  (if (not (numchk *TH))
    (setq *TH 0.0598))
  (if (not (numchk *IBR))
    (setq *IBR 0.0625))
  (if (not (angchk *BA))
    (setq *BA 90))

  ;get input and store in global variables
  (setq *TH
        (numinp "Material Thickness" *TH)
        *IBR
        (numinp "Inside Bend Radius" *IBR)
        *BA
        (anginp "Bend Angle" *BA)
        *KF ;set k-Factor to 40%
        0.40)    ;[or, could use (numinp)]
  
  ;calculate OBLO and IBLO for use later
  (setq IO
        (* (tan (/ (dtr *BA) 2)) *IBR)
        OO
        (* (tan (/ (dtr *BA) 2)) (+ *IBR *TH)))

  ;ask the user what to calculate
  (initget "Oba Iba Dbl OOffset IOffset Diff") 
  (setq ret
    (getkword
      (strcat
        "Return "
        "/Iba/Dbl/OOffset/IOffset/Diff"
        ": ")))

  ;Perform the calculation
  (cond
    ( (= ret "Dbl")
      (* (dtr *BA) (+ *IBR (* *KF *TH))))
    ( (= ret "Iba")
      (- (* (dtr *BA) (+ *IBR (* *KF *TH)))
         IO
         IO))
    ( (= ret "IOffset")
      IO)
    ( (= ret "OOffset")
      OO)
    ( (= ret "Diff")
      (- OO IO))
    ( T ;Assume "Oba"
      (- (* (dtr *BA) (+ *IBR (* *KF *TH)))
         OO
         OO))))
;End-of-file

SUMMARY


The terminology and phraseology presented in this paper are intended as a reasonable basis for implementing some standards in sheet metal flat development. The procedures and utilities presented hardly scratch the surface when it comes to solving the many problems that are encountered in practice. Nevertheless, having a firm grasp on these basics will help to develop a sense of how to tackle the more difficult problems.

The full presentation associated with this paper covers some more detailed examples of applications for the AutoLISP utilities, and gives many real-world examples of flat-development problems and solutions.

1