INTRODUCTION

Coke Drums are big.  Believe it or not, they just keep getting bigger!

Refining Industry Coke Drum

Coke Drums in refining take the heaviest part of the crude that is left over in distilling and heats it up until it begins to break down (crack) into lighter compounds - the stuff that makes more money.  It was a process that matured back in WWII when the need to get every usable ounce of crude drove the technology.

They usually are built in sets of 4s so they can be ran through their cycles without interrupting the continuous process of the crude units.

A 4 Drum Coker

One thing to be aware of is that they grow.  Since they are cyclic, they go from ambient temperature to nearly 1000F every couple of days.  In turn, they grow when its hot and shrink back when its cold.  This can cause issues with attachments to the drum such as level and temperature transmitters.  If you put the attachment too close to a nearby permanent structure like a hand rail, as the drum grows, it could grow into the handrail, busting the transmitter or its attachment nozzle resulting in a horrible leak and fire.

This project grew out of necessity (pun intended).  At work, we wanted to replace a component at the bottom of the drum with one that had some attachments.  Gut tells you that it can't be growing much in that direction or it would have run into the floor and bottom out its spring can supports.  But, the question was asked and no one had true engineering data on the matter.  So, in the spirit of Makevember 2019, a project was born.  We're going to measure drum growth at different levels from bottom to top using an Arduino Mega solution.

PROJECT DESIGN

Arduino Mega

LCD 2x 16, I2C

Real Time Clock

Proximity SensorProximity Sensor

Arduino SD/Ethernet Shield

Two 12V-8AH Batteries

For this project, I expanded my Modbus Datalogger components with a new code base and a proximity sensor.  The concept is straight forward:

• lay a proximity sensor under an existing attachment at the base of the coke drum
• log the distance measured every second for a week across multiple drum cycles
• hope your sensor doesn't get crushed

We stuck it under the Bottom Unheading Valve.  This is a picture of one from the manufacturers site:

Delta Valve - Bottom of Coke Drum

Autodesk Fusion 360 Exploded View of the Brains

Autodesk Fusion 360 Exploded View of Sensor

The sensor side (on the left) looks pretty crazy, I know.  What you have is a base made to hold 1/8" plate of steel to give it some mass.  The vents in the bottom were put in just to save material.  The black part pictured is just the lid of the base, but it has some bosses on it so screws can secure the proximity sensor while giving clearance to the proximity sensors underside components.  The black part also has two tabs.  These allow the cover on top to snap in place.  There is also a separate cable stress relief piece floating around there.  It was printed separately so I could replace it for different cable sizes.  That cover simply snaps to the base lid for a unique look.  Most importantly, it doesn't simply blow away.

To protect the brains from the weather, I installed it in a Class I Div II Enclosure which then was put into a Pelican Case.  The Pelican Case has a port that allows me to connect the sensor to the case.  The port on the inside allows the brains to then connect to it.

Weather Tight Pelican Case

NEMA Enclosure for Class I, Div 2 Areas

The current draw was 120-150 mA.  So, I got over 4 days of unattended remote monitoring logging data every second.

CODE

The code records the time, temperature, and distance every second.  After 30 readings, it writes the block to an SD card.  With a 16Gig SD card, it gets 17 years of storage!.

It takes the DS3231 and HCSR04 libraries to pull this off as well as LiquidCrystal_I2c.h.  You can download them from the Arduino IDE under the menu Tools-->Manage Libraries.

//GrowthTrackerby Sean J. Miller 2019
#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include "DS3231.h"
#include <HCSR04.h>
LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display
UltraSonicDistanceSensor distanceSensor(45, 43); //45 is the brown wire
RTClib RTC; //real time clock
DS3231 mytemp;
float the_distance;
String the_text="";
int counter=0;
void setup() {
  Serial.begin(9600);
  
  lcd.init();
  lcd.display();
  lcd.backlight();
  lcd.setCursor(0,0);
  lcd.print("  Miller");
  lcd.setCursor(1,1);
  lcd.print("GROWTH TRACKER");
  pinMode(4, OUTPUT);
  digitalWrite(4, HIGH);                      // To disable slave select for SD card; depricated.
  delay(2000);
}
void loop() {
  the_distance=distanceSensor.measureDistanceCm();
  lcdprint("T:" + String(mytemp.getTemperature()) + " D:" + ((the_distance/2.54)/12),0);
  lcdprint(getTime(),1);
  the_text=the_text + getTime() + "," + the_distance + "," + String(mytemp.getTemperature()) + '\n';
  if (++counter >30) {
    writeToFile(the_text);
    the_text="";
    counter=0;
  }
  delay(1000);
}
void lcdprint(String the_message, int row){
  lcd.setCursor(0,row);
  String the_temp=the_message + "                ";
  
  lcd.print(the_temp.substring(0,16));
}
String getTime() {
  DateTime now = RTC.now();
  return (String)(now.year()) + '-' + (String)(now.month()) + '-' + (String)(now.day()) + " " + (String(now.hour())) + ":" + (String)(now.minute()) +":" + (String)(now.second());
}
void writeToFile(String the_string) {
  // Open serial communications and wait for port to open:
  File myFile;
  if (!SD.begin(4)) {
    lcdprint("FAILED CARD!",0);
    lcdprint("FAILED CARD!",1);
    return;
  }
  // open the file. note that only one file can be open at a time,
  // so you have to close this one before opening another.
  myFile = SD.open("growth.txt", FILE_WRITE);
  // if the file opened okay, write to it:
  if (myFile) {
    myFile.print(the_string);
    // close the file:
    myFile.close();
    
    lcdprint("Write success!",1);
    
    delay(2000);
  } else {
    // if the file didn't open, print an error:
    lcdprint("Error with File",0);
    while (1);
  }
}

FINISHED PRODUCT

To connect the proximity sensor and LCD, both using I2C communication, I made a two daughter boards you can see if you zoom in below.  These were just protoboards to allow for wire-to-board connectors to hook up the sub components.  I liked the reliability and ease of an ethernet cord.  Since I had some cable, connectors, and crimpers handy, I crimped some custom length cables to connect the sensor to the suitcase and the suitcase to the Arduino stored within a NEMA enclosure.

Growth Tracker in Real Life

Growth Tracker Showing an Active Measurement

FIELD RESULTS

The data was absolutely useful.  I stripped it down for academic discussion of the trend without giving units, scale, or time.  You'll have to do it on your own if you want all that or join my team.  :-)

Academic Version of the Data

A few observations:

• Due to the dusty environment, many readings showed error.  However, the error couldn't be more convenient in that it rarely can error lower than the actual distance.  This is because when it fails, its because the fastest path for the sound to get back was obstructed and a relfection (which is a longer path back) was recorded instead.  In turn, I just need to look at the bottom of the data.  It is a great smooth trend following process physical conditions of the drum showing healthy movement in a safe range.
• The bottom trend against temperature of the process (not on this graph) can tell you if you have an unhealthy mechanical stop.  Stoving up the bottom of the drum can lead to cracks on the drum skirt that pins it down to the building structure.  If that were the case, my next step would be to inspect the large can and its buddies to ensure they are not gagged or at their max compression in the cold empty state.

Delta Valve From their Website. 

Note the Spring Can in the Middle - it can cause problems restricting drum growth.

PROTOTYPE #2

I was very happy with how easily I was able to get this data.  So much - I'm working on prototype #2 with the Arduino MKR Zero over the holiday - it is Makevember, after all.

Growth Track 2.0 Under Development

This version cuts the running power from 160mA to 60mA.  In addition, I can enter a sleep state that I wake up from periodically either via Real Time Clock trigger or by the MKR built in code functionality. 

Now that I've seen the rate that the data changes by physics, I know I can also just take data every 30 seconds versus every second.  So, I'll wake it up every 30, take 5 readings, record the lowest, and then go back to sleep.

With this new design, I'll easily get over a week of battery life allowing me to get multiple drum cycles recorded without having to ever visit the structure in between.  That's easier on me, the operator, and the engineers.  Awesome!!

PROJECT SUMMARY

This was a fun project in that a challenge came up at work and due to my Project14 experiences and community engagement, I could readily envision a fast, very affordable solution.  In fact, I made V1.0 from spare parts - didn't cost the company a dime.  :-).  Life gets fun when a hobby and work intersect, that is for sure.

For a permanent solution, I'd leverage the Open Source aspect of Arduino to my own custom PCB with appropriate wire-to-board connectors.

Happy 2019 Makevember!

Sean

project14 element14 makevember 2019