Recommendation wanted for analog pressure sensing 0-512 psi

I have an Arduino Mega2560 and need to measure pressures produced in an approximately 1"D x 5"L tube over a 0-512 psi range. I figure that 1/2 psi resolution should be possible, but have no experience with pressure sensing.

I’ve drafted this function to return (2x) pressure readings

/*----------------------------------------------------------------------------*/
/* Read 2 x reactor pressure                                                  */
/*----------------------------------------------------------------------------*/
int get_pres(void)
{  int i,t;                            /* Loop index and pressure variable    */
   for (i = t = 0; i < 8; i++)         /* Until all 8 readings are summed     */
      t += analogRead(PRES);           /* Accumulate 8 pressure readings      */
   return t / 8;                       /* Return reactor pressure value       */
}                                      /*  end: get_pres()                    */
/*----------------------------------------------------------------------------*/

What I think I’m looking for are specific sensor recommendations and some guidance in how to use them for the task at hand.

For anyone who might be interested there’s an application overview at LENR Project

I think you should search for 0-5V pressure sensors and connect them. Afterwards when you have some reading, just use arduino map function to map the input to your readings in PSI

does this answer your question?

Kenny - I've been searching, and so far haven't turned up anything that looked promising. I'll continue searching, but it seemed like a good idea to check the forum to see if anyone had enough experience to suggest specific devices and/or manufacturers.

If the devices are linear, the mapping is trivial - but if the device used isn't linear, then the Arduino mapping function won't be adequate. That part of the problem shouldn't be difficult, but should probably wait for device selection, yes?

A bit of searching found this: http://www.gaugestore.com/. They have a large variety of sensors that look suitable, not really hobbyist pricing though :wink:

$465 for a #34240 stainless steel 0-500 psi (absolute) transducer is going to be tough to handle, but it's at least a starting point.

It's not a commercial project, but neither is it a hobbyist endeavor. Beside, this thing is only going to be an arm's length away when the pressure starts to build - I figure I'm worth at least that much. :)

Thanks!

I work a lot with these things and stuff like PLC's etc.

$200,- is a price i paid before, for a 4-20mA version.... this is real cheap! Maybe ebay has something, but i think your price is like normal and if you'd like Danfoss than prepare to pay like $800-$900 :~ Believe me the price scares the hell out of me each time....

This is good to know. Now that I have a starting point I'll do some bargain hunting - but the pressure sensor will play two key roles in this project: (1) It allows the Arduino to automatically scram the reactor if pressure indicates a runaway reaction rate (which, I hope, will prevent explosions) and (2) it'll provide the pressure portion of the data this entire lash-up is intended to produce.

I didn't expect to spend that much, but if that's what it takes to do the job, I'll make it happen.

Excellent input - thanks to all!

Can't you do that digital with a pressurestat? thats way cheaper, also please don't trust any processor and make safety outside your program REALLY importand :)

please don’t trust any processor and make safety outside your program REALLY important

This is one of those times when, for better or for worse, the processor will have to be trusted. There will be a panic button to dump the hot hydrogen in the reactor to a vacuum tank and kill all externally-applied power, but the Arduino can initiate a shutdown ever so much faster than a human brain can process the need for a shutdown and get that message to a hand.

The reactor is being monitored for pressure, temperature, beta particles, and gamma radiation. Pressure is the safety-critical parameter, but any pressure increase will be the result of an increase in temperature (and possibly by an increase in radiation events). Any significant deviation from expected behavior in any of these categories will (at least initially) trigger an immediate (within a msec) total shutdown - and the complete shutdown sequence will take less than 50 msec from beginning to end.

Pressure is the safety-critical parameter

Given that, despite the cost, it might be worth having several gauges being read.

[quote author=Morris Dovey link=topic=100293.msg752283#msg752283 date=1333810132]

please don't trust any processor and make safety outside your program REALLY important

This is one of those times when, for better or for worse, the processor will have to be trusted. There will be a panic button to dump the hot hydrogen in the reactor to a vacuum tank and kill all externally-applied power, but the Arduino can initiate a shutdown ever so much faster than a human brain can process the need for a shutdown and get that message to a hand.

The reactor is being monitored for pressure, temperature, beta particles, and gamma radiation. Pressure is the safety-critical parameter, but any pressure increase will be the result of an increase in temperature (and possibly by an increase in radiation events). Any significant deviation from expected behavior in any of these categories will (at least initially) trigger an immediate (within a msec) total shutdown - and the complete shutdown sequence will take less than 50 msec from beginning to end. [/quote]

In real industrial process control units such a vessel would have in addition to human manual operated shutdown and automated safety controls and shutdown, there would also be pressure operated blow off valve(s) (PSV, pressure safety valve) attached to the vessel who's pressure relief setting is higher then normal operating pressure but below the maximum safe vessel overpressure rating as specified in the nameplate data for the vessel. These are self contained valves that don't require any external power or controls to release vessel pressure to either the atmosphere or routed via piping to some safe containment equipment. Such safety items are dictated by industry practices, insurance company requirements, and in many places by regulatory requirements.

Lefty

@retrolefty - Yuppers, and if I had the resources for PSVs I'd use 'em. I'm including the manual shutdown even though I believe that even a little Arduino will be hugely more effective.

If there were a fusion industry I wouldn't need to go through this exercise. There's no insurance company involvement so any requirements they might have don't apply, and since there aren't any fissionable materials or unstable isotopes involved the AEC/NRC doesn't have any jurisdiction. OSHA would probably go nuts if they knew, but there's neither business nor employment involved, so all they can do is stomp their feet and swear.

It's just one crazy old programmer building and testing a heat source for a tiny (shoe box size) no-moving-parts portable nuclear power plant. Actually, this is probably the safest part of the project - once the heat source has been proven, it'll go into a sealed container to heat water beyond its critical temperature and pressure (in the neighborhood of 374°C and 3200 psi). That's when it'll become interesting... :grin:

Still can’t you use a pressurestat? that’s just one setting by hand but still you can buy a few for that money,

as for the safety’s I build quite a few cooling installations and i place a blow off valve and a pressurestat for safety
and than some pressure transmitters for alarm and running parameters.
It’s up to you but i don’t go further than an occasionally working electrics with power on.

The purpose of this apparatus is to determine two sets of (pressure,temperature) pairs: the first for "ignition" (the conditions at which the reactor first begins to output more power than is being input), and the second for "self-sustaining" (the conditions at which external power can be disconnected without causing the reaction to stop). I expect that the two sets of points will describe a pair of (first quadrant) hyperbolic curves.

Secondary purposes include experimenting with a method of controlling the reaction rate once the self-sustaining mode is achieved to conserve fuel when output requirements shrink and to determine how to optimally increase reactor output when there is a surge in demand. Hence my interest in a single reasonably high-resolution measurement device.

Scramming the reactor isn't difficult. All that's needed is to open a (solenoid) valve to a vacuum tank, which simultaneously evacuates the hydrogen fuel component and precipitously drops the reaction chamber pressure and temperature below those required for ignition.

Okay i see,

Well i build some things in the past where i needed to "go cheap" and what i did for a constant pressure is two pressurestats with timers so when the high pressurestat is true i start with a timer and increase capacity from my compressor and the low one the opposite.

But sometimes you would really need to know the exact pressure at all times, and sometimes you can do with a few settings.

I can speak only for myself with my working experience in my expertise, i have no idea what kind of settings or conditions you need. But i can read you're doing some interesting stuff and that's always cool! Keep up the good work! :)

Thanks. I understand (and appreciate!) your suggestion, but a quick look at my test sequence control function should provide you with some insights as to why I want the capability I asked about:

/*----------------------------------------------------------------------------*/
/* Find a complete set of LENR ignition (pressure,temperature) pairs          */
/*----------------------------------------------------------------------------*/
void lenr(void)
{  startup(0-0);                       /* Configure hardware for operation    */
   note0("Startup complete");          /* Log startup completion              */
   /*-------------------------------------------------------------------------*/
   /* Run a sequence of tests at progressively higher pressures               */
   /*-------------------------------------------------------------------------*/
   for (tgt_p = min_p; SAFE && (tgt_p <= max_p); tgt_p += inc_p)
   {  note1("Testing pressure",tgt_p);
      /*----------------------------------------------------------------------*/
      /* Run a sub-sequence of tests at progressively higher temperatures     */
      /*----------------------------------------------------------------------*/
      for (tgt_t = min_t; SAFE && (tgt_t <= max_t); tgt_t += inc_t)
      {  saf_t = tgt_t + mar_t;
         note1("Target temperature",tgt_t);
         note1("Safety threshold",saf_t);
         /*-------------------------------------------------------------------*/
         /* Perform a single LENR reaction test (t0 is global current temp)   */
         /*-------------------------------------------------------------------*/
         warmto(tgt_t);
         if (SAFE && (t0 >= tgt_t) && sustain(tgt_t))
         {  note1("Sustained",t0);
            break;
         }
      }
      note0("Temperature sequence complete");
      if (SAFE) coolto(min_t = tgt_t - 10);
   }
}

(running a nuke with an Arduino reminds me of the move CHina syndrome (?) in which a nuke plant was operated by C64's).

If the devices are linear, the mapping is trivial - but if the device used isn't linear, then the Arduino mapping function won't be adequate. That part of the problem shouldn't be difficult, but should probably wait for device selection, yes?

Check multiMap for this - http://arduino.cc/playground/Main/MultiMap -

Furthermore a remark just based upon my gut feeling. Never build a nuke myself. I see in your lenR code a nested loop - temperature loop inside pressure loop - and if I recall my physics correctly these two are allways correlated except for adiabatic processes (P.V)/(n.T) = R . My gut feeling says that you should check both pressure and temp in every iteration.

I’ve never built one before, too. :grin:

I originally planned to use a BeagleBoard, but the application isn’t all that demanding - and the little Mega2560 combines a better mix of the I/O capabilities I need with adequate speed and memory to do the job. I’d have liked it better if it had an FPU, but I can manage without.

I’m monitoring and logging pressure, temperature, and radiation level at 1Hz in a dedicated task. Each time samples are taken the code examines all three values, and calculates both first and second derivatives of pressure and temperature with respect to time. I think these will be enough for early detection of behavior instability.

Even though my startup() function includes subjecting the reaction chamber to a vacuum (twice) to remove oxygen, I’m concerned that water vapor could be produced by the H2 reduction of oxidized Ni (fuel) or Cu (reaction chamber inner wall). Water vapor pressure is described by the Antoine Equation up to its critical point, above which it behaves like an ideal gas with a very large R value. I have a graph at Antoine Equation that contrasts the behavior of water with an ideal gas. It’s an eye-opener.

A large part of the code I’m writing is targeted at finding any possible excuse to scram the reactor. That’s going to be an inconvenience, but I intend to understand everything I can before I “soften” the code’s “twitchiness”.

I'd have liked it better if it had an FPU, but I can manage without.

familiar with this one? - http://www.micromegacorp.com/umfpu-v3.html - - http://www.micromegacorp.com/downloads/documentation/Arduino-uMFPU%20V3_1.pdf -

disclaimer : no experience with it, it is still somewhere on a todo list ..

Looks interesting. Perhaps you can move it closer to the top of your to-do list? ]:)