Food drying with renewable energy

Increases in energy costs are a signal for industry to audit its energy use and survey new plant that lowers energy use.

The food processing industry in Victoria has received quotes for natural gas with prices more than doubling in just a few years.

Echuca-based food processor Kagome expects to pay $3.6 million for gas this year, up from $2.4 million last year, despite plans to use less gas. Kagome employs more than 200 people. 

Natural gas is the dominant form of energy use for the food processing plant at KAGOME Australia

Kagome Australia's processing plant receives about 4,000 tonnes of tomatoes each day during the harvest period of 70 days. Natural gas is used to evaporate water from the tomatoes for the production of tomato paste.

Evaporating 1,000 tonnes of water from 4,000 tonnes of tomatoes each day can use an enormous amount of energy. This isn't necessary but it depends on how it is done.

One way to evaporate 1,000 tonnes of water that does use an enormous amount of energy is to simply put batches into large cauldrons with gas burners beneath them. Allow the tomatoes in the cauldrons to simmer until the desired volume of water has evaporated.

This way requires 2,257 gigajoules of thermal energy that converts 1,000 tonnes of water into steam. If this heat energy is supplied by natural gas costing $9 per gigajoule, the daily energy bill would be about $20,000 and the total bill over the tomato harvest period of 70 days woul be about $1.4 million.

There are several other ways to perform the same process using much less energy.

For instance, the energy needed to convert 1 kilogram of water into water vapour is 2,257 kilojoules. The same amount of energy can be recovered when that kilogram of water vapour is condensed back into water.

Mechanical Vapour Recompression (MVR)

The mechanical vapour compressor uses a very small amount of electrical energy to transfer a very large quantity of heat energy from the condensing steam back into the cauldron of tomatoes where it boils off an identical amount of water.
The cost saving of this method is all of the natural gas used in the inefficient method of converting 1,000 tonnes of water into water vapour. This method also produces distilled water while continually recycling the latent heat of evaporation in the water vapour as it condenses back into water.

The condensed water produced may have some value too as a pure, distilled by-product.

Equipment using this method is commercially available. One type is marketed as "forced circulation evaporators". These are for concentrating fruit paste (tomato paste, peach paste, apricot paste and etc.) and some other products with high viscosity. Another type is marketed as "falling film evaporators". These are for concentrating products with low viscosity, for example: fruit juice, milk etc.

The value of the energy savings may make it worthwhile for Kagome Australia to invest in a forced circulation evaporator and eliminate the need for natural gas.

---

Value for investment dollars - Snowy Hydro vs Plasma Gasifiers

The Snowy Hydro 2.0 project is one possible way to store renewable energy.
For each 100 megawatt-hours of electricity stored about 70 megawatt-hours is likely to be generated and delivered to consumers - after allowing for pumping, generation and distribution losses.

If the wholesale price of electricity is $70 per megawatt-hour, each 100 megawatt-hours to storage will cost $7,000. The amount available for delivery - 70 megawatt-hours - will thus cost $100 per megawatt-hour. (That is $7,000 for the 100 megawatt-hours of electricity stored divided by the 70 megawatt-hours delivered to consumers.)

The result is a 40 percent increase in the wholesale price of electricity.
If the purpose is to lower the price of electricity, Snowy Hydro 2.0 project isn't looking too good on this part of the assessment.

The next step is to consider the cost of constructing the scheme, and the need to pay interest to the investors on the amount. This is another problem for the goal of reducing the price of electricity. It is aggravated by the fact that the project lead time means that interest costs accumulate for many years before there is any opportunity to begin recovering those costs from electricity consumers.

Another possible of way of storing renewable energy is to run plasma gasification units with electricity to be stored, converting waste that would otherwise go to landfill into synthesis gas.

Westinghouse Plasma Gasification
Converting Waste Into Clean Energy for a Healthier Planet

These plants are able to deliver over double the amount of energy that is used to operate them.
For each 100 megawatt-hours of electricity costing $7,000 stored in synthesis gas, at least 200 megawatt-hours is available for delivery to consumers - reducing the wholesale price of electricity to $35 per megawatt-hour - a reduction of 50 percent in this stage of the analysis.

Unlike Snowy Hydro 2.0, the assessment of value for investment dollars gets better, not worse, in the next phase. The elimination of waste heading to landfill represents a further cost-saving for investors.

That plasma gasification units can be built quickly means the return on investment begins far sooner than is possible for Snowy Hydro 2.0.

Related post - Efficient renewable energy storage, waste recycling and zero fossil fuels

Robots go faster with Interrupt Service Routines

Example of an Arduino Uno sketch that uses an interrupt service routine to measure distance with an ultrasonic sensor.

JSN-SR04T DC5V Waterproof Ultrasonic Module Distance Measuring Sensor

A small modification allows the sketch to use both the interrupt service routine and the blocking "pulseIn()" statement that causes the processor to wait for the measurement to be completed. Notice the number of times the loop() subroutine is executed while waiting for each measurement to be completed.

Sample output - 
Measurement obtained by interrupt service routine only
======================================================
Number of times loop() executed while measurement being taken: 228
isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
distance from interrupt service routine 28   cm

Number of times loop() executed while measurement being taken: 1360
isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
distance from interrupt service routine 149   cm


Sample output - 
Measurement obtained by both 
interrupt service routine and "pulseIn()" statement
===================================================
Number of times loop() executed while measurement being taken: 1
isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
distance from pulseIn() statement 27   cm
distance from interrupt service routine 28   cm


Number of times loop() executed while measurement being taken: 1
isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
distance from pulseIn() statement 148   cm
distance from interrupt service routine 149   cm

Click on the button below to copy the sample sketch.

// JSN-SR04T-2.0 ultrasonic distance measurement module can provide 
// 20cm-600cm non-contact distance sensing function.
// Distance in centimetres is calculated from the duration of 
// a pulse that lasts for the time in microseconds till the 
// device detects an echo from a short burst of ultrasonic pulses.

// Distance (centimetres) = duration / 58
// Distance (inches) = duration / 148

// For the maximum distance of 600 cms, 
// duration is 600 * 58 = 34800 microseconds.
// If there is no obstacle within 600 cms, 
// the sensor's processor terminates the pulse after 38000 microseconds.
// Reference: 
//           JSN-SR04T-2.0 
//           20-600 cm Ultrasonic Waterproof Range Finder

// Initial sample sketch using pulseIn statment from 
// "Weather-proof Ultrasonic Sensor" at -
// https://www.dfrobot.com/wiki/index.php/Weather-proof_Ultrasonic_Sensor_SKU_:_SEN0207


// Rewritten to use an interrupt service routine (ISR) to calculate distances
// Use an interrupt pin for digital input 
// See https://www.arduino.cc/reference/en/language/functions/external-interrupts/attachinterrupt/ 
#define ECHOPIN 2// Pin to receive echo pulse on an interrupt pin for Arduino Uno
#define TRIGPIN 3// Pin to send trigger pulse

// Use volatile variables for processing ISR result from echopin
// See https://www.arduino.cc/reference/en/language/variables/variable-scope--qualifiers/volatile/
#include <util/atomic.h> // this library includes the ATOMIC_BLOCK macro.

const unsigned int max_valid_value = 35000;

unsigned int echo_value_from_pulseIn;
unsigned int echo_value_from_ISR;
int distance_value_from_pulseIn;
int distance_value_from_ISR;

int loopcounter = 0;

unsigned long last_distance_measure_time;

volatile unsigned long time_start_for_echo_wait;
volatile unsigned long time_end_of_echo_wait;

unsigned long from_isr_time_start_for_echo_wait;
unsigned long from_isr_time_end_of_echo_wait;
volatile unsigned long time_of_echo_change; // only used inside the ISR 
                                            // to temporarily hold time of entry to ISR

volatile byte isr_start_occurred = 0;
volatile byte isr_end_occurred = 0;
volatile byte isr_change_occurred = 0;

boolean measurement_inflight = false;  // Set to true when a measurement is commenced
boolean measurement_ready = false;     // Set to true when a measurement is completed 
                                       // and ready to print and/or save

void setup() {
  Serial.begin(115200);
  pinMode(ECHOPIN, INPUT_PULLUP); // enable internal pullup resistor
  pinMode(TRIGPIN, OUTPUT);
  last_distance_measure_time = millis();
  // attach interrupt handler
  attachInterrupt (digitalPinToInterrupt (ECHOPIN), EchoChange, CHANGE);  
}

void loop() {
  loopcounter++; // Keep track of how many times the loop is executed. 
                 // There are no program delays when using the
                 // interrupt service routine to measure distance.
  if (millis() - last_distance_measure_time > 1000) { // Start a new measurement, 
                                                      // clearing any indication of previous ones
    last_distance_measure_time = millis();
    measurement_inflight = true;
    measurement_ready = false;
    loopcounter = 1;  // The first time in loop() for this measurement
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
       // code with interrupts blocked (consecutive atomic operations will not get interrupted)
       isr_start_occurred = 0;
       isr_end_occurred = 0;    
       isr_change_occurred = 0;
    }
    digitalWrite(TRIGPIN, LOW); // Set the trigger pin to low for 2uS
    delayMicroseconds(2);
    digitalWrite(TRIGPIN, HIGH); // Send a 10uS high to trigger ranging
    delayMicroseconds(10);
    digitalWrite(TRIGPIN, LOW); // Send pin low again 
    
    // To compare accuracy of the measurment techniques, comment out next line and uncomment line below it.
    echo_value_from_pulseIn = 0;
    //echo_value_from_pulseIn = pulseIn(ECHOPIN, HIGH, 40000); // timeout for JSN-SR04T-2.0 sensor is 38mSecs 
                                                               // if no pulse received (ie 38000 microSeconds)
    // To obtain measurements with only the Interrupt Service Routine 
    // and have no delays in the loop() leave the above commenting as is.
    
    Serial.println("");
    Serial.print("Echopin high. Result: ");
    Serial.println(echo_value_from_pulseIn);
  }

  if (measurement_inflight) { // If a measurement has been started, 
                              // check values set in the ISR to see if it has completed.
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
      // code with interrupts blocked (consecutive atomic operations will not get interrupted)
      // int result = input_from_interrupt; // example
      if (isr_end_occurred == 1) { // Copy end time stored by interrupt service routine
        from_isr_time_end_of_echo_wait = time_end_of_echo_wait;
        measurement_inflight = false; // The measurement has now been completed
        measurement_ready = true;      // The measurement is ready to be calculated, printed and saved
        if (isr_start_occurred == 1) { // Copy start time stored by interrupt service routine
          from_isr_time_start_for_echo_wait = time_start_for_echo_wait;
        }
      }              
    }
  } //end if measurement_inflight

  if (measurement_ready) {
    Serial.println("");
    Serial.print("Number of times loop() executed while measurement being taken: ");
    Serial.println(loopcounter);
    Serial.print("isr_start_occurred = ");
    Serial.print(isr_start_occurred);
    Serial.print(", isr_end_occurred = ");
    Serial.print(isr_end_occurred);   
    Serial.print(", isr_change_occurred = ");
    Serial.println(isr_change_occurred);  
    if (echo_value_from_pulseIn > 0 && echo_value_from_pulseIn < max_valid_value) {
      distance_value_from_pulseIn = echo_value_from_pulseIn / 58;
      Serial.print("distance from pulseIn() statement ");
      Serial.print(distance_value_from_pulseIn);
      Serial.println("   cm");
    } else {
      Serial.println("No valid measurement obtained by pulseIn statement.");
    }
    echo_value_from_ISR = from_isr_time_end_of_echo_wait - from_isr_time_start_for_echo_wait;
    if (echo_value_from_ISR > 0 && echo_value_from_ISR < max_valid_value) {
      distance_value_from_ISR = echo_value_from_ISR / 58;
      Serial.print("distance from interrupt service routine ");
      Serial.print(distance_value_from_ISR);
      Serial.println("   cm");  
    } else {
      Serial.println("No valid measurement obtained by interrupt service routine.");
    }
   measurement_ready = false; // Don't redo this process until a new measurement is made.
  } // end if measurement_ready

  // Any other processing ...
}

// Interrupt Service Routine that is executed when the echo pin changes (from low to high and high to low).
void EchoChange() {
  time_of_echo_change = micros(); // Save the time in microseconds when the ISR is entered
  isr_change_occurred++;
  if (digitalRead(ECHOPIN) == HIGH) { // Start of timing pulse  
    time_start_for_echo_wait = time_of_echo_change;
    isr_start_occurred = 1;    
  } else { // End of timing pulse
    time_end_of_echo_wait = time_of_echo_change;
    isr_end_occurred = 1;
  }
}

// Sample output - measurement obtained by interrupt service routine only
// ======================================================================
//  Echopin high. Result: 0
//  
//  Number of times loop() executed while measurement being taken: 228
//  isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
//  distance from interrupt service routine 28   cm
//  
//  Echopin high. Result: 0
//  
//  Number of times loop() executed while measurement being taken: 1360
//  isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
//  distance from interrupt service routine 149   cm


// Sample output - measurement obtained by both interrupt service routine and "pulseIn()" statement
// ===============================================================================================
//  Echopin high. Result: 1619
//  
//  Number of times loop() executed while measurement being taken: 1
//  isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
//  distance from pulseIn() statement 27   cm
//  distance from interrupt service routine 28   cm
//  
//  Echopin high. Result: 8617
//  
//  Number of times loop() executed while measurement being taken: 1
//  isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
//  distance from pulseIn() statement 148   cm
//  distance from interrupt service routine 149   cm