How to Poka-yoke CAD Drawings

The following question has been posed on many Internet discussion forums: Has anyone poka-yoked a computer-aided design (CAD) system? The goal of poka-yoke, or mistake-proofing, is to design a process or mechanism that prevents an error from occurring. In the world of machine and industrial design, CAD systems are one of the best forms of poka-yoke available in that they capture and eliminate defects prior to build. Yet as any engineer can attest, mistakes can and do get through – when this happens the costs can be enormous. Here is a look at some CAD system poka-yoke research to inspire and improve the use of CAD systems.

Adding Poka-yokes to Software

Gojko Adzic, a strategic software delivery consultant who specializes in Lean Six Sigma (LSS) quality improvements for software systems, writes that software testing – another form of poka-yoke – must be fast and anticipate both system and user failure. He cites the auto-save feature in software applications as an excellent example of a software poka-yoke.

Speed is essential for CAD system testing because slow tests cause the user of the CAD system to look for ways to circumvent the test. Gojko advocates dividing poke-yoke tests into fast and slow categories to ensure that some tests can be automated and implemented quickly. Tests must also be foolproof and reliable unto themselves. If test results are not consistent, for instance, users will ignore the outcomes, thus limiting the power of tests.¹

Establishing CAD Standards

Establishing process standards is familiar to engineers in the medical device field because it is part of the compliance validation process required by the Federal Drug Administration for both software validation and designs.^2,3 In most cases the manufacturers of medical devices must establish and maintain quality design procedures and standards to control the design process and ensure that certain device requirements are met. This legislation includes almost every conceivable form of front-end CAD poka-yoke: design and development planning, design input and output procedures, design review, design validation, design transfer and changes procedures, history procedures and verification procedures.

Even here, however, the requirement for verification or applying a poka-yoke mentality to the drawings and CAD systems themselves is not clear. Drawings can come in from a system or be vendor-verified. If the drawings come via a vendor, should they be verified again? To complicate matters further, it is common for more than one type of CAD system to be used; this also can cause problems. For example, 3D construction solid geometry software may not be entirely compatible with the 3D boundary representation modeling software. In many cases it is impossible to 100 percent poka-yoke the final drawings and production processes.

One of the best – and easiest – ways to poka-yoke CAD drawings is to establish company CAD standards and procedures. These standards can be automated and include standards that are verified by personnel. The priority is to set up CAD standards using LSS thinking and then design a series of poka-yokes to anticipate and prevent future CAD issues.

Software that automatically standardizes drawings imported from vendors can save both time and money for a company. For example, designs from a vendor that have not been run through a CAD standardization process may have elements that do not meet the company’s requirements. When that happens, time is lost and expenses are wasted as the drawings are brought up to the expected standard.

CAD standards are unique to each business process, but some standards and procedures that any company should consider implementing include the following:

• Design input and output
• Design review
• Design validation
• Design transfer
• Design changes
• Computer issue
• Data update and code verification tests
• Archiving
• Verification

Return on Investment on CAD Verification

CAD verification is essentially poka-yoke for the poka-yoke builders. If implemented correctly, CAD verification has the potential to have a significant positive impact on product quality and return on investment (ROI). This is particularly the case when LSS is applied to the verification process to ensure that the process reduces errors as intended. There is plenty of room for improvement in CAD systems, making this an excellent place for the implementation of LSS strategies to increase profits and efficiency.

A 2010 study of CAD verification and automation performed by Naga Info Solutions, an Indian IT solutions company, found that the automation of the verification process for complicated drawings could significantly eliminate errors and increase ROI, in this case, in a government department. This study represents the types of gains that can be realized through CAD verification.⁴

The government department in the study used CATIA (a multi-platform 3D interactive software solution designed by Dassault Systemes written in C++) for CAD. Through a series of interviews related to the existing quality assurance system, Naga found the following issues regarding CAD-drawing verification:

1. The manual identification and confirmation of the dimensions, notes and other aspects of the CAD files was time consuming and susceptible to human error.
2. There was no standardized method for calculated dimensions.
3. Even small modifications required that the entire verification process be repeated.
4. Details related to the drawings often had to be extracted by hand.
5. There was no standardized process for managing drawings and revisions.

Naga concluded through their study that CATIA was the “best” CAD system. CATIA needed, however, either customization or a software application to make it a better fit for the department – as is often the case when standard CAD systems are used. Large sections of the programs are not used and/or those parts that are used do not include customized poka-yokes that meet the day-to-day demands of the people that use them. CAD customization can greatly increase the efficiency of the entire process. Naga suggested a number of improvements for CAD systems overall.

For drawing extraction and analysis:

1. Automatically assign standardized parameters. This means that all dimensions, names, dates, notes, authors and more will be standardized at the input stage.
2. Automatically assign parameters that would have 3D drawings available adjacent to the corresponding 2D drawings.
3. Automatically identify the drawing type in relationship to the assembly.
4. Automatically assign minimum and maximum limits to establish tolerance in specific categories of drawings.
5. Add separate classification input points of geometric tolerance, angles and chamfers to standardize these fields for each drawing.
6. Automatically highlight the last parameter number and classification in the drawings.
7. Automatically assign another parameter for every drawing revision.

For the archiving of drawings in the database:

1. Automatically extract a needed parameter, including its related values, and save it to the database.
2. Compartmentalize the data in the database by relevant parameters.
3. Link parameter database to a specific field for the insertion of the revision number.
4. Include automatic avoidance of duplicate numbering for assignments.
5. Include access rights for editing values stored within the database.

After developing a Windows application to go with a MySQL database, the manual verification process for a complicated drawing was reduced from an average of 120 minutes to a mere 4 minutes.

Making CAD Systems Better

In practice, every CAD system works with a unique set of demands that are placed upon both the system and its users. Through the use of poka-yokes and customized verification implemented with Lean Six Sigma processes, CAD systems can be made more productive and efficient.

References

1. Adzic, Gojko. “The Poka-Yoke Principle and How to Write Better Software.” http://gojko.net/2007/05/09/the-poka-yoke-principle-and-how-to-write-better-software/. Accessed May 30, 2012.
2. U.S. Food and Drug Administration. “CFR – Code of Federal Regulations Title 21.” http://www.accessdata.fda.gov/scripts/cdrh/cfdocs/cfcfr/CFRSearch.cfm?CFRPart=820&showFR=1&subpartNode=21:8.0.1.1.12.1. Accessed May 30, 2012.
3. U.S. Food and Drug Administration. “General Principles of Software Validation; Final Guidance for Industry and FDA Staff.” http://www.fda.gov/medicaldevices/deviceregulationandguidance/guidancedocuments/ucm085281.htm. Accessed May 30, 2012.
4. Naga Info Solutions. “CAD Automation – Case Study: Quality Assurance.” http://www.nagainfo.com/downloads/naga_casestudy_cad_auto.pdf. Accessed May 30, 2012.

Additional Readings

1. American Machinist. “Fully Automated Part-to-CAD Measurement Verification.” http://www.americanmachinist.com/304/Issue/Article/False/88156/Issue. Accessed May 30, 2012.
2. Bernard, Alian. Global Product Development: Proceedings of the 20th CIRP Design Conference. Springer Science+Business Media, New York, 2010.
3. Kasak, Jim, Weber, Ross and Stump, Holly. ”Formal Verification Deployment Return on Investment.” Chip Design Magazine, June 2009.
4. Mangassarian, Hratch, Veneris, Andreas and Benedetti, Marco. “Robust QBF Encodings for Sequential Circuits and Applications to Verification, Debug and Test.” IEEE Transactions on Computers, Volume 59, Issue 7, July 2010.
5. Metzger, M.,  Anane, A., Rousseau, F., et. al., “Introspection Mechanisms for Runtime Verification in a System-level Design Environment.” Microeletronics Journal, Volume 40, Issue 7, July 2009.
6. Mohib, Ahmed and ElMaraghy, Hoda. “Tolerance-based Localization Algorithm: Form Tolerance Verification Application.” The International Journal of Advanced Manufacturing Technology, Volume 27, Numbers 5-8, 2010.
7. Montali, Marco. Specification and Verification of Declarative Open Interaction Models. Springer Science+Business Media,  New York, 2010. (Features CAD case studies that demonstrate greater efficiency through the use of poka-yokes when they are combined with CAD systems in three distinctly different examples.)
8. Poppendieck, Mary and Poppendieck, Tom. Lean Software Development: From Concept to Cash. Addison-Wesley Professional, Boston, 2008.
9. Shmukler, Alex and Fischer, Anth. “Verification of 3D Freeform Parts by Registration of Multiscale Shape Descriptors.” The International Journal of Advanced Manufacturing Technology, Volume 49, Numbers 9-12, 2010.
10. Wyatt, William G. Accessing AutoCAD Architecture. Autodesk Press, San Rafael, Calif., 2012.