What Is A Cooling Tower

Published July 26, 2020 © Apache-2.0

Autonomous Cooling Tower (A.C.T)

Majority of cooling towers today are still reliant on human intervention when there's even the simplest of alarms.

BeginnerFull instructions provided1 hour810

Things used in this project

Hardware components

STM32L0 Discovery kit LoRa, Sigfox, low-power wireless

Seeed Studio Grove - Water Sensor

Software apps and online services

Arduino IDE

Helium Console

Story

In the project that I'll be depicting below I'll demonstrate how some aspects of a cooling tower can be controlled autonomously. There are some system errors that don't require human intervention and we will be focusing on that part in this project. Before we begin a few words about what exactly is a cooling tower.

What Is A Cooling Tower?

A cooling tower is a specialized heat exchanger in which air and water are brought into direct contact with each other in order to reduce the water’s temperature. As this occurs, a small volume of water is evaporated, reducing the temperature of the water being circulated through the tower.

Water, which has been heated by an industrial process or in an air-conditioning condenser, is pumped to the cooling tower through pipes. The water sprays through nozzles onto banks of material called “fill, ” which slows the flow of water through the cooling tower, and exposes as much water surface area as possible for maximum air-water contact. As the water flows through the cooling tower, it is exposed to air, which is being pulled through the tower by the electric motor-driven fan.

When the water and air meet, a small amount of water is evaporated, creating a cooling action. The cooled water is then pumped back to the condenser or process equipment where it absorbs heat. It will then be pumped back to the cooling tower to be cooled once again.

The above pictures depict a basic idea of how a cooling tower works and the error messages I sometimes get on the control panel.

The video below depicts hot water flowing into the top of the honeycomb of the cooling tower but as you can see the amount of water needed to flow correctly down the honeycomb has to reach the top of the pvc pipes which is clearly not happening and that could be a problem.

TheParts:

For this project will be using the STM 32 Discovery board provided to us by Helium and a water level sensor. A water level sensor is a simple device that is used to measure the level and the volume of water inside a container, will be using a conductive-type water level sensor, where the change in resistance of parallel wires over varying depths of water is converted to voltage.

WaterLevel Sensor Setup:

S: A0

+: 5v

-: Ground

SetupDiagram:

(Aboveyou see a picture of the Serial monitor output)

(Below is a picture of the sensor wiring)

HeliumConsole (Setup):

Now will be setting up a device on the Helium Console, its a fairly straight forward and simple process. Lets get started.

Step 1:

First thing we do is register for a free account: https://www.helium.com/console

Step 2:

Now were going to setup a device to connect with the Helium Network later on.

In the picture below you can see that I've already setup a device for this specific project.

Click on + Add New Device, you'll be prompted with this window.

Once the device is ready you'll see it appear on the device menu. Click on the device name to open the device details menu.

As you see with the above picture here you are given all the information you'll be using later on to transmit information to the Helium Network. You can also add a label to your device by simply scrolling down to Attached Labels and clicking on + Add Label, this way you can better organize your devices.

Helium Network (Setup):

Now will be connecting the device we just created with the Helium Network and start transmitting information. For this part will be using a Hardware-As-A-Service session to depict how the Helium Network functions, a big thanks to "HolyChris" with "Project Kerosene" for providing a platform to run our code on, check out the project kerosene on github https://github.com/HolyChris/ProjectKerosene.

Step 1:

First we need three things from the Device Details Console to be able to run our code and get live data. Go back to the Helium Console window, click on Devices and then click on the device you created before. For our code example we need three things, Device EUI, App EUI and App Key. Now click on the arrows next to the keys to change the format to least significant bit (lsb) or most significant bit (msb).

The Arrows are the ones in the blue circle, for Device EUI and App EUI once you clicked on the arrows click on the arrows depicted in the green circles to change to lsb format.

Step 2:

Now we start a session to test out our device, click on this link to request a session:

https://rerobots.net/sandbox/helium/gy4Z4kRfgn4yAuavaWeGWQjjF1WJeQt6

Step 3:

On the session window we just opened were shown a live view of the devices that are online and a window with the code will be using, on the bottom you can also see we have a few buttons like "build", "flash", "download source file" etc..

On line 63,67, 71 is where we need to input our device info in the correct format, Device EUI, App EUI and App key.

Device EUI : lsb

App EUI : lsb

App Key : msb

Once were done with that we hit the "flash" button and on the console window on the right hand side and we see the code upload to the board. If there are no errors and the console window says "success" in a little while live data will be streamed to our Helium Console window.

As you can see in the picture below the console shows us how many packets were transferred and when.

int val = 0;  // holds the value
int pin = A0; // water sensor pin used
  
void setup() { 
  Serial.begin(9600);
} 
  
void loop() { 
   
  val = analogRead(pin); //Read data from analog pin and store it to val variable
   
  if (val<=100){ Serial.println("Water Level: Empty"); }
  else if (val>100 && val<=300){ Serial.println("Water Level: Low"); } 
  else if (val>300 && val<=330){ Serial.println("Water Level: Medium"); } 
  else if (val>330){ 
    Serial.println("Water Level: High"); 
  }
  delay(1000); 
}

#include <SPI.h>
#include <arduino_lmic.h>
#include <arduino_lmic_hal_boards.h>
#include <arduino_lmic_hal_configuration.h>
#include <arduino_lmic_lorawan_compliance.h>
#include <arduino_lmic_user_configuration.h>
#include <hal/hal.h>
#include <lmic.h>

//#include <Adafruit_seesaw.h>
#include <LSM6DSOSensor.h>
#include <LIS2DW12Sensor.h>
#include <LIS2MDLSensor.h>
#include <LPS22HHSensor.h>
#include <STTS751Sensor.h>
#include <HTS221Sensor.h>
#include <CayenneLPP.h>

#ifdef ARDUINO_SAM_DUE
#define DEV_I2C Wire1
#elif defined(ARDUINO_ARCH_STM32)
#define DEV_I2C Wire
#else
#define DEV_I2C Wire
#endif

// Sensors
LSM6DSOSensor *AccGyr;
LPS22HHSensor *PressTemp;
HTS221Sensor *HumTemp;


// This should also be in little endian format
// These are user configurable values and Helium console permits anything
static const u1_t PROGMEM DEVEUI[8] = {FILLMEIN};
void os_getDevEui(u1_t *buf) { memcpy_P(buf, DEVEUI, 8); }

// This is the "App EUI" in Helium. Make sure it is little-endian (lsb).
static const u1_t PROGMEM APPEUI[8] = {FILLMEIN};
void os_getArtEui(u1_t *buf) { memcpy_P(buf, APPEUI, 8); }

// This is the "App Key" in Helium. It is big-endian (msb).
static const u1_t PROGMEM APPKEY[16] = {FILLMEIN};
void os_getDevKey(u1_t *buf) { memcpy_P(buf, APPKEY, 16); }

CayenneLPP lpp(51);
static osjob_t sendjob;

// Schedule TX every this many seconds (might become longer due to duty
// cycle limitations).
const unsigned TX_INTERVAL = 60;

// Pin mapping
//
// Adafruit BSPs are not consistent -- m0 express defs ARDUINO_SAMD_FEATHER_M0,
// m0 defs ADAFRUIT_FEATHER_M0
//
#if defined(ARDUINO_SAMD_FEATHER_M0) || defined(ADAFRUIT_FEATHER_M0)
// Pin mapping for Adafruit Feather M0 LoRa, etc.
const lmic_pinmap lmic_pins = {
    .nss = 8,
    .rxtx = LMIC_UNUSED_PIN,
    .rst = 4,
    .dio = {3, 6, LMIC_UNUSED_PIN},
    .rxtx_rx_active = 0,
    .rssi_cal = 8, // LBT cal for the Adafruit Feather M0 LoRa, in dB
    .spi_freq = 8000000,
};
#elif defined(ARDUINO_AVR_FEATHER32U4)
// Pin mapping for Adafruit Feather 32u4 LoRa, etc.
// Just like Feather M0 LoRa, but uses SPI at 1MHz; and that's only
// because MCCI doesn't have a test board; probably higher frequencies
// will work.
const lmic_pinmap lmic_pins = {
    .nss = 8,
    .rxtx = LMIC_UNUSED_PIN,
    .rst = 4,
    .dio = {7, 6, LMIC_UNUSED_PIN},
    .rxtx_rx_active = 0,
    .rssi_cal = 8, // LBT cal for the Adafruit Feather 32U4 LoRa, in dB
    .spi_freq = 1000000,
};
#elif defined(ARDUINO_CATENA_4551)
// Pin mapping for Murata module / Catena 4551
const lmic_pinmap lmic_pins = {
    .nss = 7,
    .rxtx = 29,
    .rst = 8,
    .dio =
        {
            25, // DIO0 (IRQ) is D25
            26, // DIO1 is D26
            27, // DIO2 is D27
        },
    .rxtx_rx_active = 1,
    .rssi_cal = 10,
    .spi_freq = 8000000 // 8MHz
};
#elif defined(MCCI_CATENA_4610)
#include "arduino_lmic_hal_boards.h"
const lmic_pinmap lmic_pins = *Arduino_LMIC::GetPinmap_Catena4610();
#elif defined(ARDUINO_DISCO_L072CZ_LRWAN1)
const lmic_pinmap lmic_pins = *Arduino_LMIC::GetPinmap_Disco_L072cz_Lrwan1();
#else
#error "Unknown target"
#endif

void readSensors()
{
    // Read humidity and temperature.
    float humidity = 0;
    float temperature = 0;
    HumTemp->GetHumidity(&humidity);
    HumTemp->GetTemperature(&temperature);

    // Read pressure and temperature.
    float pressure = 0;
    PressTemp->GetPressure(&pressure);

    // Read accelerometer and gyroscope.
    int32_t accelerometer[3];
    int32_t gyroscope[3];
    AccGyr->Get_X_Axes(accelerometer);
    AccGyr->Get_G_Axes(gyroscope);

    // Clear Payload
    lpp.reset();

    // Pack Packload
    lpp.addTemperature(1, temperature);
    lpp.addRelativeHumidity(2, humidity);
    lpp.addBarometricPressure(3, pressure);
    lpp.addAccelerometer(4, accelerometer[0], accelerometer[1], accelerometer[2]);
    lpp.addGyrometer(5, gyroscope[0], gyroscope[1], gyroscope[2]);

    // Debug Print Data
    Serial.print("| Hum[%]: ");
    Serial.print(humidity, 2);
    Serial.print(" | Temp[C]: ");
    Serial.print(temperature, 2);
    Serial.print(" | Pres[hPa]: ");
    Serial.print(pressure, 2);
    Serial.print(" | Acc[mg]: ");
    Serial.print(accelerometer[0]);
    Serial.print(" ");
    Serial.print(accelerometer[1]);
    Serial.print(" ");
    Serial.print(accelerometer[2]);
    Serial.print(" | Gyr[mdps]: ");
    Serial.print(gyroscope[0]);
    Serial.print(" ");
    Serial.print(gyroscope[1]);
    Serial.print(" ");
    Serial.print(gyroscope[2]);
}

void do_send(osjob_t *j)
{
    // Check if there is not a current TX/RX job running
    if (LMIC.opmode & OP_TXRXPEND)
    {
        Serial.println(F("OP_TXRXPEND, not sending"));
    }
    else
    {
        readSensors();
        // Prepare upstream data transmission at the next possible time.
        LMIC_setTxData2(1, lpp.getBuffer(), lpp.getSize(), 0);
        Serial.println(F("Packet queued"));
    }
    // Next TX is scheduled after TX_COMPLETE event.
}

void onEvent(ev_t ev)
{
    Serial.print(os_getTime());
    Serial.print(": ");
    switch (ev)
    {
    case EV_SCAN_TIMEOUT:
        Serial.println(F("EV_SCAN_TIMEOUT"));
        break;
    case EV_BEACON_FOUND:
        Serial.println(F("EV_BEACON_FOUND"));
        break;
    case EV_BEACON_MISSED:
        Serial.println(F("EV_BEACON_MISSED"));
        break;
    case EV_BEACON_TRACKED:
        Serial.println(F("EV_BEACON_TRACKED"));
        break;
    case EV_JOINING:
        Serial.println(F("EV_JOINING"));
        break;
    case EV_JOIN_TXCOMPLETE:
        Serial.println(F("EV_JOIN_TXCOMPLETE"));
        break;
    case EV_JOINED:
        Serial.println(F("EV_JOINED"));
        {
            u4_t netid = 0;
            devaddr_t devaddr = 0;
            u1_t nwkKey[16];
            u1_t artKey[16];
            LMIC_getSessionKeys(&netid, &devaddr, nwkKey, artKey);
            Serial.print("netid: ");
            Serial.println(netid, DEC);
            Serial.print("devaddr: ");
            Serial.println(devaddr, HEX);
            Serial.print("artKey: ");
            for (size_t i = 0; i < sizeof(artKey); ++i)
            {
                if (i != 0)
                    Serial.print("-");
                Serial.print(artKey[i], HEX);
            }
            Serial.println("");
            Serial.print("nwkKey: ");
            for (size_t i = 0; i < sizeof(nwkKey); ++i)
            {
                if (i != 0)
                    Serial.print("-");
                Serial.print(nwkKey[i], HEX);
            }
            Serial.println("");
        }
        // Disable link check validation (automatically enabled
        // during join, but because slow data rates change max TX
        // size, we don't use it in this example.
        LMIC_setLinkCheckMode(0);
        break;
    /*
  || This event is defined but not used in the code. No
  || point in wasting codespace on it.
  ||
  || case EV_RFU1:
  ||     Serial.println(F("EV_RFU1"));
  ||     break;
  */
    case EV_JOIN_FAILED:
        Serial.println(F("EV_JOIN_FAILED"));
        break;
    case EV_REJOIN_FAILED:
        Serial.println(F("EV_REJOIN_FAILED"));
        break;
        break;
    case EV_TXCOMPLETE:
        Serial.println(F("EV_TXCOMPLETE (includes waiting for RX windows)"));
        if (LMIC.txrxFlags & TXRX_ACK)
            Serial.println(F("Received ack"));
        if (LMIC.dataLen)
        {
            Serial.println(F("Received "));
            Serial.println(LMIC.dataLen);
            Serial.println(F(" bytes of payload"));
        }
        // Schedule next transmission
        os_setTimedCallback(&sendjob, os_getTime() + sec2osticks(TX_INTERVAL),
                            do_send);
        break;
    case EV_LOST_TSYNC:
        Serial.println(F("EV_LOST_TSYNC"));
        break;
    case EV_RESET:
        Serial.println(F("EV_RESET"));
        break;
    case EV_RXCOMPLETE:
        // data received in ping slot
        Serial.println(F("EV_RXCOMPLETE"));
        break;
    case EV_LINK_DEAD:
        Serial.println(F("EV_LINK_DEAD"));
        break;
    case EV_LINK_ALIVE:
        Serial.println(F("EV_LINK_ALIVE"));
        break;
    /*
  || This event is defined but not used in the code. No
  || point in wasting codespace on it.
  ||
  || case EV_SCAN_FOUND:
  ||    Serial.println(F("EV_SCAN_FOUND"));
  ||    break;
  */
    case EV_TXSTART:
        Serial.println(F("EV_TXSTART"));
        break;
    default:
        Serial.print(F("Unknown event: "));
        Serial.println((unsigned)ev);
        break;
    }
}

void setup()
{
    // Initialize I2C bus.
    DEV_I2C.begin();

    AccGyr = new LSM6DSOSensor(&DEV_I2C);
    AccGyr->Enable_X();
    AccGyr->Enable_G();
    PressTemp = new LPS22HHSensor(&DEV_I2C);
    PressTemp->Enable();
    HumTemp = new HTS221Sensor(&DEV_I2C);
    HumTemp->Enable();

    delay(5000);
    while (!Serial)
        ;
    Serial.begin(9600);
    Serial.println(F("Starting"));

#if defined(ARDUINO_DISCO_L072CZ_LRWAN1)
    SPI.setMOSI(RADIO_MOSI_PORT);
    SPI.setMISO(RADIO_MISO_PORT);
    SPI.setSCLK(RADIO_SCLK_PORT);
    SPI.setSSEL(RADIO_NSS_PORT);
// SPI.begin();
#endif

#ifdef VCC_ENABLE
    // For Pinoccio Scout boards
    pinMode(VCC_ENABLE, OUTPUT);
    digitalWrite(VCC_ENABLE, HIGH);
    delay(1000);
#endif

    // LMIC init
    os_init();
    // Reset the MAC state. Session and pending data transfers will be discarded.
    LMIC_reset();

    // allow much more clock error than the X/1000 default. See:
    // https://github.com/mcci-catena/arduino-lorawan/issues/74#issuecomment-462171974
    // https://github.com/mcci-catena/arduino-lmic/commit/42da75b56#diff-16d75524a9920f5d043fe731a27cf85aL633
    // the X/1000 means an error rate of 0.1%; the above issue discusses using
    // values up to 10%. so, values from 10 (10% error, the most lax) to 1000
    // (0.1% error, the most strict) can be used.
    LMIC_setClockError(1 * MAX_CLOCK_ERROR / 40);

    LMIC_setLinkCheckMode(0);
    LMIC_setDrTxpow(DR_SF8, 20);
    LMIC_selectSubBand(1);

    // Start job (sending automatically starts OTAA too)
    do_send(&sendjob);
}

void loop() { os_runloop_once(); }

namespace Arduino_LMIC
{

class HalConfiguration_Disco_L072cz_Lrwan1_t : public HalConfiguration_t
{
public:
    enum DIGITAL_PINS : uint8_t
    {
        PIN_SX1276_NSS = 37,
        PIN_SX1276_NRESET = 33,
        PIN_SX1276_DIO0 = 38,
        PIN_SX1276_DIO1 = 39,
        PIN_SX1276_DIO2 = 40,
        PIN_SX1276_RXTX = 21,
    };

    virtual bool queryUsingTcxo(void) override { return false; };
};
// save some typing by bringing the pin numbers into scope
static HalConfiguration_Disco_L072cz_Lrwan1_t myConfig;

static const HalPinmap_t myPinmap = {
    .nss = HalConfiguration_Disco_L072cz_Lrwan1_t::PIN_SX1276_NSS,
    .rxtx = HalConfiguration_Disco_L072cz_Lrwan1_t::PIN_SX1276_RXTX,
    .rst = HalConfiguration_Disco_L072cz_Lrwan1_t::PIN_SX1276_NRESET,

    .dio =
        {
            HalConfiguration_Disco_L072cz_Lrwan1_t::PIN_SX1276_DIO0,
            HalConfiguration_Disco_L072cz_Lrwan1_t::PIN_SX1276_DIO1,
            HalConfiguration_Disco_L072cz_Lrwan1_t::PIN_SX1276_DIO2,
        },
    .rxtx_rx_active = 1,
    .rssi_cal = 10,
    .spi_freq = 8000000, /* 8MHz */
    .pConfig = &myConfig};

}; // end namespace Arduino_LMIC

Credits

George Kartsonas

19 projects • 46 followers

Autonomous Cooling Tower (A.C.T)

Things used in this project

Hardware components

Software apps and online services

Story

What Is A Cooling Tower?

Code

Water Sensor Code

Arduino Helium Network Sensor Code

Credits

George Kartsonas

Comments

Embed the widget on your own site

Autonomous Cooling Tower (A.C.T)

Autonomous Cooling Tower (A.C.T)

Things used in this project

Hardware components

Software apps and online services

Story

What Is A Cooling Tower?

Code

Water Sensor Code

Arduino Helium Network Sensor Code

Credits

George Kartsonas

Comments

Related channels and tags