The DRAM Cell

// DRAM cell retention logger - measures how long ONE bit survives, against temperature.
// Board: ESP32 DevKit v1.  Cell: one N-channel MOSFET + one small capacitor.
//
// WHAT THIS MEASURES AND WHY IT IS THE WHOLE POINT OF DRAM:
// a 1T1C cell stores a bit as charge on a capacitor. Nothing holds it there. Leakage through
// the access transistor and the junction drains it, so the bit has a HALF-LIFE - and the entire
// architecture of DRAM exists to read every cell and write it back before that half-life runs out.
//
// You are measuring the number that forces refresh to exist.
//
// WIRING
//   GPIO 25  ->  WRITE_PIN   -> through 1k -> cell node (drives the bit line)
//   GPIO 26  ->  WORDLINE    -> MOSFET gate (opens the access transistor)
//   GPIO 34  ->  SENSE       -> cell node, ADC1, HIGH IMPEDANCE
//   DS18B20 on GPIO 4 for temperature
//
// THE MEASUREMENT IS DESTRUCTIVE, exactly as it is in a real DRAM: reading the cell shares its
// charge with the ADC input and disturbs it. Real DRAM solves this by writing the bit back
// immediately after every read. Here we simply re-write and start again.

#include <OneWire.h>
#include <DallasTemperature.h>

#define WRITE_PIN     25
#define WORDLINE_PIN  26
#define SENSE_PIN     34
#define ONE_WIRE_PIN   4

#define VREF        3.30f
#define ADC_MAX     4095.0f
#define LOGIC_HIGH  0.60f     // fraction of Vref still counted as a stored '1'

OneWire oneWire(ONE_WIRE_PIN);
DallasTemperature sensors(&oneWire);

float readCellVolts() {
  // Read WITHOUT opening the wordline would read nothing - the cell is isolated.
  // So: open the access transistor, sample fast, close it again.
  digitalWrite(WORDLINE_PIN, HIGH);
  delayMicroseconds(50);
  uint32_t acc = 0;
  for (int i = 0; i < 8; i++) acc += analogRead(SENSE_PIN);
  digitalWrite(WORDLINE_PIN, LOW);
  return (acc / 8.0f) * (VREF / ADC_MAX);
}

void writeCell(bool bit) {
  pinMode(WRITE_PIN, OUTPUT);
  digitalWrite(WRITE_PIN, bit ? HIGH : LOW);
  digitalWrite(WORDLINE_PIN, HIGH);     // open access transistor
  delay(5);                              // let the capacitor charge
  digitalWrite(WORDLINE_PIN, LOW);      // close it - the charge is now trapped
  pinMode(WRITE_PIN, INPUT);            // float the bit line so it cannot hold the node up
}

void setup() {
  Serial.begin(115200);
  pinMode(WORDLINE_PIN, OUTPUT);
  digitalWrite(WORDLINE_PIN, LOW);
  pinMode(WRITE_PIN, INPUT);
  analogSetPinAttenuation(SENSE_PIN, ADC_11db);
  sensors.begin();

  Serial.println("# DRAM cell retention");
  Serial.println("run,temp_c,ms_since_write,cell_v,still_one");

  for (int run = 1; run <= 5; run++) {
    sensors.requestTemperatures();
    float t = sensors.getTempCByIndex(0);

    writeCell(true);
    unsigned long t0 = millis();
    float v = VREF;

    // sample until the stored '1' is no longer readable as a '1'
    while (v > LOGIC_HIGH * VREF) {
      v = readCellVolts();
      Serial.printf("%d,%.2f,%lu,%.4f,%d\n", run, t, millis() - t0, v,
                    v > LOGIC_HIGH * VREF ? 1 : 0);
      delay(25);
      if (millis() - t0 > 60000UL) break;      // give up after a minute
    }
    Serial.printf("# run %d: retention = %lu ms at %.1f C\n", run, millis() - t0, t);
    delay(1000);
  }

  Serial.println("# DONE - paste the CSV into the jupyter step and fit the decay");
  Serial.println("# Then WARM THE CELL with a hairdryer and run again. Leakage roughly");
  Serial.println("# doubles every 8-10 C, so retention roughly halves. That temperature");
  Serial.println("# dependence is why real DRAM refreshes far more often when hot.");
}

void loop() { }