Brinell Hardness Greenbelt Project

The Problem

Brinell hardness measurement is a rough measure of the material properties of a sample. It involves using a hard ball to indent the material being tested, and then measuring the size of the indentation. The larger the indentation, the softer the material is since the ball was able to penetrate deeper. Sounds pretty simple, right?

This process actually has many variables that can affect the end result.

The indentation can be performed using several different tools including a stationary air-driven press or a hand-pumped device that is clamped onto the item being tested.

When reading the indentation, many different methods can be used. The cheapest method uses a handheld microscope-like device with two vertical lines. The user lines up one of these lines with the edge of the indentation and then twists a knob to bring the other line to the opposite side. By reading the amount incremented by the knob, the diameter of the punch can be measured. From there, the associated hardness reading is looked up from a table. Obviously this method includes a lot of human factors such as vision, motion accuracy, and correctly interpreting the result.

Manual scope diagram

In contrast, there are automated systems available which will capture an image of the indentation and calculate the hardness reading with minimal human influence.

Before indenting a surface, it must be smoothed using a grinder. This can be either a sand or stone based grinding wheel, and the grinding force applied can vary between inspectors performing the operation. This can work-harden the surface, and this effect depends on the original hardness of the material.

Our task was to determine how some of these variables affect the final hardness reading and propose solutions where needed.

Hardness Reading

The main focus of the project was the reading of the hardness punch. Different manufacturing cells used different methods of measuring the indentation diameter, so we wanted to see what kinds of errors resulted from each method. We devised a double-blind gage R&R test that had the inspectors check pre-punched samples using three methods of measurement: the manual scope and two competing automated systems.

iPhone Dump 6.1.14 1727

To obtain known hardness values, we used calibration blocks straight from the manufacturer. These blocks had 5 punches already made with hardness values disclosed for each. We covered up the hardness values, randomly assigned a number to each block, and then randomized the order in which the blocks would be handed to the inspectors. The inspectors would then test each punch and announce the result, which we would record. Each block was tested at least 3 times by each inspector with each punch measuring method.

Once all the data was gathered, we were able to remove the masking tape from each block, revealing its true hardness. We then compared the readings from the inspectors to the known values to compute the error in hardness reading using statistical analysis methods such as ANOVA.

Grinding

Another variable in the process is the way in which the surface is prepared. The two main kinds of grinding media are sand or stone, so these are the two that we tested. However, the user can exert any amount of force, which could potentially work harden the surface and skew the result.

Grinding hi res

Thus, we devised a test fixture that would measure the load applied by the grinder using a load cell. I set up a simple data acquisition system using National Instruments hardware and LabVIEW, and we had the inspector grind softly, with moderate force, and with great force on various samples. We correlated the load applied to the resulting hardness reading to determine the effect (if any) of grinding force and media.

Heat Treating

Another factor that applies to work hardening the surface is the initial strength of the material. To test this, we got to use an industrial furnace to heat treat samples to achieve material properties ranging from very soft to very hard.

These samples were used in the grinding experiment to see how much the hardness could be changed by the grinding process based on the initial hardness of the material.

Conclusion

While I cannot disclose the results of the study (it's GE proprietary information), I can say that I learned a lot about material properties and hardness testing from this project. I was able to use many aspects of engineering to come up with experiments to test various aspects of the hardness testing process, and I got to interface with inspectors, cell leaders, shop floor managers, master black belts, material scientists, and even the vice president of engineering.

I was pleased to receive the following feedback from my manager:

"Thank you for the work you did on your Green Belt project. Your ability to work with various functions and groups enabled you to gather valuable data that led to critical changes to improve the hardness reading process. The experience and knowledge you gained during this process will benefit you as you grow in your career. Thank you for putting forth a tremendous effort!"

Diverter Seal Test System

This was my very first automated test that I was responsible for. I learned a lot of lessons along the way that have stuck with me for every project since.

The Goal

This test involved using a hydro-pump to pressurize two elastomeric seals. The customer wanted to pressurize the seals, hold pressure, bleed pressure, and then repeat until failure. Every 500 cycles, the seals needed to be leak tested by performing an extended hold and checking for pressure drop. If a seal failed, testing on it should cease, but the other seal should continue to be cycled until failure.

The Hardware

This was the first time I designed both the plumbing and electrical controls for a test.

Since each seal needed to be tested independently, each one had its own air-actuated isolation valve. On the pressure supply side, an air-driven hydro pump was turned on/off with a solenoid valve that supplied shop air. The supply side also had an accumulator which would be pumped up during hold periods, significantly reducing cycle time by increasing the speed at which the seals would fill with water. A common bleed valve was used to depressurize the seals between cycles.

Diverter Test Setup 1

The electrical board housed a cRIO with the necessary analog input and digital output cards. To control the air-actuated valves, a manifold with solenoid valves was used to convert electrical signals to valve actuation.

The Software

The interface had a simple plumbing schematic as well as manual and automatic controls. If a seal failure was detected, a large red indicator would light and the seal would be automatically isolated for the remainder of testing.

iPhone Dump 6.1.14 5149

Performance and Lessons Learned

The system worked well at first, detecting seal failure by checking for a percentage of pressure drop during the hold periods. However, a failure mode crept up on me that I didn't account for: if the seal failed during pump-up, it would leak and never build enough pressure to move to the next test step. Thus, one day when we arrived to the lab, there was water all over the floor since the pump just kept on trying!

From that day forward, all automated system test steps included some sort of time-out to ensure the system stops the test if a condition is not met within a reasonable amount of time.

Family Day Projects

Bicycle Pump Race

Bike Race Photo

This was my first-ever LabVIEW automation project. Two players compete to inflate their bicycle tire to the target pressure in the shortest time. For each tire, I plumbed up a manifold with a pressure sensor, solenoid valve, and bicycle pump. Until the countdown starts, the solenoid valve bleeds pressure to avoid any cheating. Once the race starts, the valve closes and the players can inflate their tires. Once one of the tires reaches the goal pressure, a winner is announced and the solenoid valves open to bleed pressure and make ready for the next pair of challengers.

LabVIEW Pong

The classic game pong re-imagined with LabVIEW! Based off the LabVIEW Simple PONG 2 player game in the NI community pages. I modified the code to take in an integer as the pong paddle's position, and then I wired up a couple of laser distance sensors to provide the player's location. We flipped a projector 90° to face the floor, and I modified the interface to be white on black with square "pixels" for a retro experience.

Ultrasonic Instrument

IMG_6188 Crop

Taking inspiration from my Theremax project, this simple device takes in a distance reading from an industrial ultrasonic sensor and generates a tone from a speaker and lights up a ping pong ball using an RGB LED.

Mini Flow Loop

IMG_0228

I wired and set up the proportional valve, flow rate sensor, pressure sensor, and temperature sensor on this small-scale flowloop and wrote the software to control it. Its purpose is to show how flow rate and flow restriction influence pressure and temperature in flow.

High Speed Data Acquisition System

The Task

A GE manufacturing and assembly facility was just beginning a  factory acceptance test on a large, complex piece of equipment called a BOP stack, or blowout preventer stack. This 4-story tall piece of safety equipment has dozens of hydraulic functions, and engineers wanted to better understand how actuating one function can affect pressures in the other functions. Thus, I was asked to create a data acquisition system that could read up to  48 pressure sensors at 1000 Hz each. The system had to be waterproof to protect against exhaust from the hydraulic functions, and easy enough to use that any technician could use it.

IMG_1491

The Hardware

What I came up with was a pelican case containing a National Instruments CompactDAQ system housing several high-speed analog input cards. I generated a BOM (including 5000 ft of instrumentation cable!) for sourcing to procure while I worked on the software, so that by the time the hardware came in, all I had to do was assemble everything, load on the software, and bring the system over to the GE facility.

With so many sensors and wires, it was essential to have good labeling in place so that there was no doubt of which port a sensor connected to. Thus, the ports and both ends of each wire were numbered, and the port numbers were also present in the software to be matched to each sensor's serial number.

The Software

The software I wrote to collect the data was written in LabVIEW. It allowed for simple entry of the necessary calibration information for each sensor, and the user could save and load sensor data to a file. Since many of the technicians were unfamiliar with the concepts of directories and file paths, these were automatically generated based on a few data fields the technician would fill out. There was also a convenient button that would open up the latest data file for verification before moving on to the next test.

Stack DAQ Screenshot

With so many sensors recording at high speed, it was essential to buffer the data to avoid losing any. Thus, I used the concept of queuing the data and reading from this queue when writing to a file.

Since many different technicians would be using the system, I made and released a guide to get up and running with the DAQ hardware and software:

Stack DAQ Guide

System in Action

IMG_1479

Above is a photo of the system in action. The large piece of equipment in the background is the BOP, with dozens of pressure sensors attached at various key points.

Overall, the system was a great success, and the engineers were happy to get this type of data for the first time! Here is some feedback that I got from one of the engineers:

"Jeremy, Thanks for all of your hard work getting us set up to test the stacks. With your help we were able to use a lot of new technology to get data that we have never had before in this part of our business. Thanks for being so willing to help and deal with all of the setbacks we had!"

Connector Cycling System

The Task

This was a project for another GE facility that was performing cyclic testing on a piece of equipment called an H4 connector. They were expecting to perform the same series of hydraulic functions over 500 times, with each complete cycle taking around 20-30 minutes. Rather than have a technician manually actuate the various functions of the connector repeatedly (as they have done in the past), I was tasked to automate the process and acquire data from pressure sensors and LVDT position sensors.

The Hardware

I went to the facility to understand the test setup and required connections. I worked with one of my instrumentation technicians to acquire the appropriate sensors while I got to work on the programming and test system wiring. I put a cRIO, data acquisition cards, power supplies, relays, and an E-stop in a Pelican case to protect against any spray from the connector's functions. The end result I hooked into their existing test skid as shown below:

IMG_1376

The Software

The LabVIEW program I wrote included data acquisition with sensor information tracking and calibration date verification. The automated testing included safety limits at every step, and the state transitions were determined by the testing procedure. At any time, the technician could pause the system or start cycling at any step in the process. Here is the software in action with the live data feed from a few cycles:

IMG_1392

After a day of bug fixes and another day of training, the system performed well and was used to complete hundreds of cycles. The engineer on the project was pleased with the performance and gave me the following feedback:

"Thank you for all the support on the [connector] test. Your knowledge an expertise in Labview has allowed us to go from 20 cycles a day to 50 cycles a day using automation. This is a clear example of the GE Belief Learn and adapt to win by monitoring the test and making improvements along the way to help the test run smoother."

Data Acquisition Cart

A sister lab just began operations in pressure and temperature testing, but they were still using old-fashioned chart recorders to log their data. After I showed their lab manager what the ATO Lab was capable of, he requested a mobile digital data acquisition system for his lab. I went to work creating a user-friendly data acquisition system including easy-to-use software and simple hardware connections.

DAQ Cart Labeled Photo

The resulting system can read 8 4-20 mA sensors and 6 thermocouples. In addition to the system itself, I delivered a user guide and electrical schematics.

DAQ Cart Documentation Photo

Here is the system in use on its first test:

IMG_0271

The system ended up being used for all their testing, and I built a second unit for them a couple of months later. Here is the feedback I received from the lab manager:

" I spoke with all the guys and they are happy with what they have now. I just need to get you some more equipment to build us at least another 2 carts. Appreciate all the help you have helped us with. Really do appreciate all the efforts."

Features of the system:

  • Up to 10 Hz data logging from 8 4-20 mA channels and 6 Type J thermocouples
  • Sensor calibration information easily entered and resulting best-fit line is reviewed before committing  to system.
  • UPS battery backup to ensure power loss does not invalidate test data
  • System checks sensor calibration dates before acquiring data
  • Sensor data can be saved/loaded from file
  • System saves all testing parameters on shutdown and loads last parameters on startup

Memory Game Alarm Clock

IMG_8012

The Concept

I sometimes have trouble waking up in the morning, so I wanted to make a challenge for myself whenever I try to turn off my alarm clock. I already made a memory game, and I made a simple design for outputting to a 7-segment LED display, so I decided I wanted to integrate those designs into an alarm clock.

The Design

The box

I found an inexpensive aluminum project box online and decided to use it as the body for the alarm clock. I found some buttons with built-in LEDs for the memory game portion, and I decided to strategically drill holes in the front of the box to  allow the time display to shine through. Like I mention in the demo video, I didn't do a great job of this.

The Circuit Board

The main electrical components I have on the PCB are:

  • ATMega328 - system logic and I/O
  • DS1307 - Real Time Clock
  • 3V coin cell for real time clock
  • LED Display
  • MAX7219 for LCD screen
  • Buzzer for alarm
  • Resistors, capacitors, and crystal oscillators

Alarm_Clock_Simon_Schematic_Stack_pcb

In order to fit everything into the small project box, I went with a stacking PCB design with two 2-layer boards.

The buttons and lights are connected by wires to the circuit board where they are directly soldered on. In future, I would like to modify this to a plug-in connection to make it easier to take the lid off for battery replacement.

Features

  • Requires a memory game to be beaten to turn off alarm
  • All functions of alarm clock are controlled by 4 memory game buttons
  • Buttons light up whenever pressed for feedback
  • Intuitive alarm and time setting
  • Adjustable brightness
  • Adjustable difficulty
  • 12/24 hour time display modes

Demo

Making Of

The code and PCB schematics can be found on my GitHub.

ESP8266 and DHT22 – Log room temperature to a Google Sheet

I recently discovered the ESP8266: a low-cost board with a WiFi chip that also has a microcontroller that you can program with the Arduino IDE. For less than $2, this was something I had to try! So I decided that I wanted to use the ESP8266 with a DHT22 temperature and humidity sensor to log the temperature of my room in Google drive.

I wired and set it up using this guide:

https://learn.adafruit.com/esp8266-temperature-slash-humidity-webserver

But instead of a USB to serial cable, I used a UART TTL module to communicate with the board. Since the 2 x 4 pin design doesn't lend itself to use in a breadboard, I used an adapter board.

The complete circuit is shown below:

IMG_2665 IMG_2666

Once I got the module reading temperature values from the sensor, I added code to send the data to Adafruit IO using the getting started guide:

https://learn.adafruit.com/adafruit-io/arduino

I then used an IFTTT recipe to add any new Adafruit IO values to a google sheet. This is what the values look like as they come in:

Screenshot 2016-03-10 21.42.11

And here is a plot of the temperatures over time. It looks a bit jagged since the temperature is being sent over as an integer, which is fine for my purposes.

Screenshot 2016-03-10 21.35.01

The Arduino IDE code can be found on my repository: https://github.com/jerwil/ESP8266_DHT_to_Adafruit

Interlocking Laser-cut Pieces – An Experiment in Design

When I was working on my Sleep Sensei project, I designed the housing out of interlocking parts to form the case.

IMG_4886

Initial Design

When designing the interlocking portions, I arbitrarily chose that the "notches" would be as wide as twice the material thickness and as tall as the material thickness to provide a good amount of interlocking without being excessive. For example, bamboo from Ponoko is available in 3mm thickness, so the notches are 3mm x 6mm (see diagram below).

Lasercut Notch Size Largetext

Click above image to enlarge.

This worked fairly well when the parts were glued together, but if not the whole thing would just fall apart. Since I was designing this product to be a kit to be assembled by my customers, I wanted to make it as easy as possible with no glue required.

Adding Nodes to the Design

When looking to improve the design, I came across this Ponoko article about adding "nodes" to interlocking laser-cut parts to provide a tighter interface. The concept I came up with was to add nodes to both the "male" and "female" notches to create an interference fit:

Node Diagram

The problem was, I didn't know what dimensions to choose to make the fit tight enough without being too tight to assemble. I also had to make a design that is tolerant of inconsistencies in the laser cutting process. So I did a simple experiment to choose the best node size.

Node Sizing Experiment

I decided to make the width of the nodes 1/2 of the material's thickness, or 1.5 mm in the case of the bamboo I was using. But I didn't know how "tall" to make the nodes.

Node Dimensions Diagram

So I used AutoCAD to create a test piece that would test both the 90 degree connections of the corners as well as inserting into a series of holes (such as on the sides of the Sleep Sensei). The test pieces could be inserted into each other to test different combinations of node sizes. A sample test piece is shown below:

Indiviadual Test Piece

I created a series of test pieces with varying node heights, and I made 4 of each piece to account for variability in manufacturing. I etched each part with its node height so I could keep track:

All Node pieces

For example, the below test piece has a node that is 0.03 mm high:

Node Dimensions

When the parts came in, I tried all the combinations of node sizes, and I found that the fit was best with 0.05 mm nodes on both pieces. So I modified the Sleep Sensei design to include this node size:

New Sensei Design

Notches Up Close

And the design works quite well! If you check out the assembly video, you'll see that the parts snap together quite nicely.

I used the same node size for my valentine's day count-up box, and that also worked out quite well. The parts work like lego pieces: firmly snapped together but easy to take apart if needed.

Count up Box – A Valentine’s Day Gift

The Count up Box

Front

For Valentine's day 2016, I decided to make a device to count up how much time has passed since my girlfriend and I first met.

What I came up with is a fairly simple design utilizing an Arduino nano, a real time clock, an LCD screen, and a rotary encoder.

As I have some decent experience with laser cutting from my Sleep Sensei project, I decided to have the project laser cut.

Demo Video

Photos

Side Back IMG_2620

Technical Details

The knob on the top of the box is attached to a rotary encoder with a built-in momentary switch. I use this to change the unit display on screen and allow the user to adjust the date and time.

Getting the screen working was the largest challenge of this project. It is a 1602 16x2 HD44780 screen from aliexpress, and it uses an I2C converter to allow me to send it commands via an I2C interface, simplifying the wiring significantly. However, it was hard to find the correct arduino library to interface with it. After much searching and testing, the LiquidCrystal_I2C library was the one that worked for me. The documentation for this library isn't the greatest, but the commands can be found in the LiquidCrystal_I2C.h file.

The whole project is powered directly from the Arduino nano. This allows for easy code swapping and prototyping since the power cable is also the communications cable, and it simplifies the design of the circuit board since I can use the nano's on-board power supply.

The code, lasercutting files, board schematics, parts list, and more details can be found on my GitHub:

https://github.com/jerwil/Count_Up_Time

Circuit Board Design

Count Up Box Schematic Production_pcb  IMG_2618

The circuit board was designed in Fritzing, and the design files can be found on the GitHub page.