nixieclock/code/main.c

#include <avr/interrupt.h>
#include <avr/io.h>
#include <stdbool.h>
#include <stdint.h>
#include <util/delay.h>

#include <ds3231.h>

#ifndef bit
#define bit(b) (1 << b)
#endif

/**
 * high nibble: BCD output digit
 * low nibble: button inputs, leftmost button is least significant bit
 */
#define BCD_BTN_PORT PORTD
#define BTN_PIN PIND
#define BCD_BTN_DDR DDRD

/**
 * low nibble: nixie anode power
 * one bit per digit, leftmost nixie is least significant bit
 */
#define NIXIE_PORT PORTC
#define NIXIE_DDR DDRC

/**
 * other control pins
 * - bit 0: K155ID1 power (active high)
 * - bit 1: HV shutdown (active high; not connected)
 * - bit 2: dots anode power
 */
#define ETC_PORT PORTB
#define ETC_DDR DDRB

#define ETC_ID1 bit(0)
#define ETC_HVSD bit(1)
#define ETC_DOTS bit(2)

#define READ_RTC_INTERVAL_MS 71
#define BTN_DEBOUNCE_MS 50

// runtime variables
volatile uint32_t msec = 0;

struct ds3231_clock_t clock = {0};
bool flag_read_rtc = true;

bool set_mode_active = false;
uint8_t set_mode_idx = 0;
uint8_t set_mode_digits[4] = {0};

uint32_t button_inhibit_ms[4] = {0};
bool flag_button_pressed[4] = {false};

bool is_button_pressed(uint8_t id) {
  return (BTN_PIN & bit(id)) == 0;
}

void handle_button_press(uint8_t id) {
  switch (id) {
    // toggle set mode; set new time
    case 0: {
      if (set_mode_active) {
        clock.hours = set_mode_digits[0] * 10 + set_mode_digits[1];
        clock.minutes = set_mode_digits[2] * 10 + set_mode_digits[3];
        clock.seconds = 0;
        ds3231_write_clock(&clock);

        set_mode_active = false;
      } else {
        ds3231_read_clock(&clock);
        set_mode_digits[0] = clock.hours / 10;
        set_mode_digits[1] = clock.hours % 10;
        set_mode_digits[2] = clock.minutes / 10;
        set_mode_digits[3] = clock.minutes % 10;

        set_mode_active = true;
      }

      break;
    }

    // move between digits
    case 1: {
      if (set_mode_active) {
        set_mode_idx = (set_mode_idx + 1) % 4;
      }

      break;
    }

    // up
    case 2: {
      if (set_mode_active) {
        set_mode_digits[set_mode_idx]++;

        if (set_mode_idx == 0) {
          set_mode_digits[set_mode_idx] %= 3;
        } else if (set_mode_idx == 1 && set_mode_digits[0] == 2) {
          set_mode_digits[set_mode_idx] %= 4;
        } else if (set_mode_idx == 2) {
          set_mode_digits[set_mode_idx] %= 6;
        } else {
          set_mode_digits[set_mode_idx] %= 10;
        }
      }

      break;
    }

    // down
    case 3: {
      if (set_mode_active) {
        set_mode_digits[set_mode_idx]--;

        if (set_mode_idx == 0) {
          set_mode_digits[set_mode_idx] += 3;
          set_mode_digits[set_mode_idx] %= 3;
        } else if (set_mode_idx == 1 && set_mode_digits[0] == 2) {
          set_mode_digits[set_mode_idx] += 4;
          set_mode_digits[set_mode_idx] %= 4;
        } else if (set_mode_idx == 2) {
          set_mode_digits[set_mode_idx] += 6;
          set_mode_digits[set_mode_idx] %= 6;
        } else {
          set_mode_digits[set_mode_idx] += 10;
          set_mode_digits[set_mode_idx] %= 10;
        }
      }

      break;
    }
  }
}

/**
 * sets up timer0 for 1ms interrupts
 */
void timer_setup() {
  // Set the compare value to 249 to make the timer trigger once every 250 clock cycles.
  TCCR0A = bit(WGM01);
  OCR0A = 124;

  // Enable the timer and interrupts
  TIMSK0 |= bit(OCIE0A);
  sei();

  // Set clock prescaler for timer0 to 1/64 (= 250kHz)
  // This also starts the timer
  TCCR0B |= 0b00000011;
  // TCCR0B |= 0b00000101;
}

bool error = false;

int main() {
  BCD_BTN_DDR = 0xf0;  // set BCD pins as output
  BCD_BTN_PORT = 0x0f; // enable input pull-ups

  NIXIE_DDR = 0x0f;

  ETC_DDR = 0x07;
  ETC_PORT |= ETC_ID1; // enable power to K155ID1

  timer_setup();

  // button interrupts
  PCMSK2 |= 0x0f; // enable pin change interrupts on button pins
  PCICR |= bit(PCIE2);

  for (;;) {
    if (flag_read_rtc) {
      flag_read_rtc = false;

      if (ds3231_read_clock(&clock) != 0) {
        error = true;
      }

      if (clock.seconds % 2 == 0) {
        ETC_PORT &= ~ETC_DOTS;
      } else {
        ETC_PORT |= ETC_DOTS;
      }
    }

    for (int i = 0; i < 4; i++) {
      if (flag_button_pressed[i]) {
        flag_button_pressed[i] = false;
        handle_button_press(i);
      }
    }
  }
}

void clear_digits() {
  NIXIE_PORT = 0;
  BCD_BTN_PORT &= ~(0xf0);
}

void show_digit(uint8_t digit, uint8_t nixie_idx) {
  BCD_BTN_PORT &= ~(0xf0);
  BCD_BTN_PORT |= digit << 4;
  NIXIE_PORT = bit(nixie_idx);
}

// millisecond counter
ISR(TIMER0_COMPA_vect) {
  // time
  msec++;
  if (msec % READ_RTC_INTERVAL_MS == 0) {
    flag_read_rtc = true;
  }

  // dots
  if (set_mode_active && msec % 250 == 0) {
    ETC_PORT ^= ETC_DOTS;
  }

  // digits
  uint8_t nixie_idx = msec % 4;
  if (set_mode_active) {
    if (nixie_idx == set_mode_idx || msec % 16 < 4) {
      show_digit(set_mode_digits[nixie_idx], nixie_idx);
    } else {
      clear_digits();
    }
  } else {
    uint32_t digit = nixie_idx == 0   ? clock.hours / 10
                     : nixie_idx == 1 ? clock.hours % 10
                     : nixie_idx == 2 ? clock.minutes / 10
                                      : clock.minutes % 10;
    show_digit(digit, nixie_idx);
  }

  // button debounce
  for (int i = 0; i < 4; i++) {
    if (button_inhibit_ms[i] > 0) {
      button_inhibit_ms[i]--;
    }
  }
}

// button press detection
ISR(PCINT2_vect) {
  for (int i = 0; i < 4; i++) {
    if (is_button_pressed(i) && button_inhibit_ms[i] == 0) {
      flag_button_pressed[i] = true;
      button_inhibit_ms[i] = BTN_DEBOUNCE_MS;
    }
  }
}