Deep-sea dive computer on an Arduino Uno

// Deep-sea dive computer: depth, water temperature and an ascent-rate alarm.
//
//   A0       pressure transducer SIG (0.5 to 4.5 V, 0 to 0.5 MPa gauge)
//   pin 2    DS18B20 water probe DQ (4.7k pull-up to 5 V)
//   pin 8    piezo buzzer
//   A4, A5   OLED SDA and SCL (address 0x3C)
//
// # How pressure becomes depth
//
// Water is heavy. Every 10 m you go down adds about one atmosphere (1 bar,
// 100 kPa) on top of the air's own pressure at the surface. The exact rule is
// pressure = density x gravity x depth. Sea water is about 1025 kg/m3, so one
// metre of it adds 1025 x 9.81 = 10.05 kPa. The sketch turns that around:
// depth = pressure / 10.05 kPa per metre.
//
//   0 m     1 bar of air only              (gauge reading   0 kPa)
//   10 m    2 bar: the air plus one of sea (gauge reading 100 kPa)
//   40 m    5 bar                          (gauge reading 400 kPa)
//
// # Gauge or absolute?
//
// A BMP280 or BME280 is an absolute sensor: it reads 1013 hPa at the surface
// and stops at 1100 hPa, which is only about one metre of water. It is the
// wrong tool for a dive. The part used here is a stainless gauge transducer
// built for water: 0.5 V at no pressure up to 4.5 V at full scale, which is
// 0.5 MPa (500 kPa, about 50 m of sea water) on this model. Gauge means the
// air above the surface is already taken out. The sketch still reads the
// sensor at power-up and calls that zero depth, the way a real dive computer
// does on the boat before it goes in, so a sensor that is a little off at the
// surface does not make the whole dive wrong.
//
// # Ascent rate
//
// The rule of thumb for scuba is to rise no faster than about 10 m a minute,
// because the nitrogen in your blood needs time to leave. The sketch keeps the
// depth from two seconds ago and works out how many metres a minute you have
// moved since. Above the limit the bar on the screen fills past its tick, the
// screen says SLOW DOWN and the piezo beeps. At 40 m, the limit of a
// recreational dive, it sounds a steady tone instead.
//
// Drag the pressure slider to dive. Drag the temperature to cool the water.

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <OneWire.h>
#include <DallasTemperature.h>

const int PRESSURE_PIN = A0;
const int PROBE_PIN = 2;
const int BUZZER_PIN = 8;

// The transducer reads 0.5 V at 0 kPa and 4.5 V at 500 kPa, and the converter
// measures against the same 5 V supply. That is 10% to 90% of its 1023 counts.
const float COUNTS_AT_ZERO = 102.3;
const float COUNTS_PER_KPA = 818.4 / 500.0;

// Sea water: 1025 kg/m3 x 9.81 m/s2 = 10.05 kPa for every metre.
const float KPA_PER_METRE = 10.05;

const float MAX_ASCENT = 10.0;  // metres a minute
const float MAX_DEPTH = 40.0;   // metres

Adafruit_SSD1306 display(128, 64, &Wire, -1);
OneWire bus(PROBE_PIN);
DallasTemperature probe(&bus);

float surfaceCounts = COUNTS_AT_ZERO;
float depth = 0;
float maxDepth = 0;
float waterC = 20;
float ascent = 0;  // metres a minute, positive when rising

// The depth a few samples ago, kept in a four-slot ring: one slot per half
// second, so the slot about to be overwritten holds the depth two seconds back.
// Each slot remembers when it was taken, because drawing the screen takes a
// moment and the loop does not tick at exactly 500 ms.
float history[4];
unsigned long stamp[4];
uint8_t slot = 0;

unsigned long lastSample = 0;
unsigned long lastDraw = 0;
unsigned long lastTemp = 0;
unsigned long lastReport = 0;
bool tempAsked = false;

// The average of 16 reads smooths out the converter's last bit of noise.
float readCounts() {
  long sum = 0;
  for (int i = 0; i < 16; i++) sum += analogRead(PRESSURE_PIN);
  return sum / 16.0;
}

float depthFromCounts(float counts) {
  float kpa = (counts - surfaceCounts) / COUNTS_PER_KPA;
  if (kpa < 0) kpa = 0;
  return kpa / KPA_PER_METRE;
}

void alarm(bool tooFast, bool tooDeep) {
  if (tooDeep) {
    tone(BUZZER_PIN, 2000);
  } else if (tooFast && (millis() / 250) % 2 == 0) {
    tone(BUZZER_PIN, 1000);
  } else {
    noTone(BUZZER_PIN);
  }
}

void draw(bool tooFast, bool tooDeep) {
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);

  // Depth, big.
  display.setTextSize(3);
  display.setCursor(0, 0);
  display.print(depth, 1);
  display.setTextSize(1);
  display.setCursor(104, 14);
  display.print("m");

  // The line under it: deepest point and water temperature.
  display.setCursor(0, 28);
  display.print("MAX ");
  display.print(maxDepth, 1);
  display.print("m  ");
  display.print(waterC, 1);
  display.print("C");

  // Dive time as minutes:seconds.
  unsigned long s = millis() / 1000;
  display.setCursor(0, 38);
  display.print("TIME ");
  display.print(s / 60);
  display.print(":");
  if (s % 60 < 10) display.print("0");
  display.print(s % 60);

  // The ascent gauge: a box that spans 0 to 20 m/min, with a tick at the limit.
  display.drawRect(0, 50, 100, 8, SSD1306_WHITE);
  float up = ascent < 0 ? 0 : ascent;
  int fill = (int)(up * 98 / (2 * MAX_ASCENT));
  if (fill > 98) fill = 98;
  display.fillRect(1, 51, fill, 6, SSD1306_WHITE);
  display.drawFastVLine(50, 48, 12, SSD1306_WHITE);
  display.setCursor(104, 50);
  display.print((int)up);

  // The warning, flashing.
  if ((tooFast || tooDeep) && (millis() / 300) % 2 == 0) {
    display.fillRect(70, 38, 58, 10, SSD1306_WHITE);
    display.setTextColor(SSD1306_BLACK);
    display.setCursor(72, 39);
    display.print(tooDeep ? "TOO DEEP" : "SLOW DOWN");
  }
  display.display();
}

void setup() {
  Serial.begin(115200);
  Serial.println("Mokxi Uno: dive computer");
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  probe.begin();
  probe.setWaitForConversion(false);  // ask now, read later, never stall
  pinMode(BUZZER_PIN, OUTPUT);

  // Surface calibration: whatever the sensor reads now is zero metres.
  surfaceCounts = readCounts();
  for (int i = 0; i < 4; i++) {
    history[i] = 0;
    stamp[i] = millis();
  }
}

void loop() {
  unsigned long now = millis();

  if (now - lastSample >= 500) {
    lastSample = now;
    depth = depthFromCounts(readCounts());
    if (depth > maxDepth) maxDepth = depth;
    // history[slot] is the depth four samples (about two seconds) ago.
    unsigned long span = now - stamp[slot];
    ascent = span > 0 ? (history[slot] - depth) * 60000.0 / span : 0;  // m/min
    history[slot] = depth;
    stamp[slot] = now;
    slot = (slot + 1) % 4;
  }

  // The probe takes 750 ms to convert, so ask, wait, then read.
  if (!tempAsked && now - lastTemp >= 1000) {
    probe.requestTemperatures();
    tempAsked = true;
    lastTemp = now;
  } else if (tempAsked && now - lastTemp >= 800) {
    float c = probe.getTempCByIndex(0);
    if (c > -100) waterC = c;
    tempAsked = false;
    lastTemp = now;
  }

  bool tooFast = ascent > MAX_ASCENT;
  bool tooDeep = depth >= MAX_DEPTH;
  alarm(tooFast, tooDeep);

  if (now - lastDraw >= 300) {
    lastDraw = now;
    draw(tooFast, tooDeep);
  }

  if (now - lastReport >= 1000) {
    lastReport = now;
    Serial.print("depth ");
    Serial.print(depth, 1);
    Serial.print(" m, max ");
    Serial.print(maxDepth, 1);
    Serial.print(" m, water ");
    Serial.print(waterC, 1);
    Serial.print(" C, ascent ");
    Serial.print(ascent, 1);
    Serial.print(" m/min");
    if (tooDeep) Serial.print(" TOO DEEP");
    else if (tooFast) Serial.print(" SLOW DOWN");
    Serial.println();
  }
}