segment_display.h

#ifndef _SEGMENT_DISPLAY
#define _SEGMENT_DISPLAY

#include <avr/pgmspace.h>

#include "std/initializer_list.h"

namespace SegmentDisplay {

// Simple seven segment decimal decoder
const PROGMEM uint8_t DECODER[] = {
    //.gfedcba
    0b00111111, // 0
    0b00000110, // 1
    0b01011011, // 2
    0b01001111, // 3
    0b01100110, // 4
    0b01101101, // 5
    0b01111101, // 6
    0b00000111, // 7
    0b01111111, // 8
    0b01101111, // 9
    0b00000000, // *
    0b00000000, // *
    0b00000000, // *
    0b00000000, // *
    0b00000000, // *
    0b00000000, // *
    0b00000000, // EMPTY
    0b01000000, // DASH
};

template<size_t NUM_DIGITS>
class Driver {
    public:
        const static size_t EMPTY = 16;
        const static size_t DASH = 17;

        Driver(std::initializer_list<uint8_t> digit_pins, std::initializer_list<uint8_t> segment_pins) {
            size_t i = 0;
            for(auto pin : digit_pins) {
                if(i >= NUM_DIGITS) break;
                this->digit_pins[i++] = pin;
                pinMode(pin, OUTPUT);
            }
            i = 0;
            for(auto pin : segment_pins) {
                if(i >= 8) break;
                this->segment_pins[i++] = pin;
                pinMode(pin, OUTPUT);
            }

            for(i = 0; i < NUM_DIGITS; ++i) {
                setDigit(i, EMPTY);
            }
        }

        void setDigits(std::initializer_list<uint8_t> digits) {
            size_t i = 0;
            for(auto digit : digits) {
                setDigit(i++, digit);
            }
        }

        void setDigit(size_t num, uint8_t digit) {
            if(num >= NUM_DIGITS || digit > 17) return;
            this->state[num] = pgm_read_byte_near(DECODER + digit);
        }

        void setSegments(size_t num, uint8_t segments) {
            if(num >= NUM_DIGITS) return;
            this->state[num] = segments;
        }

        void refresh(unsigned int light_time = 0) {
            size_t i = 0;
            for(auto segment : segment_pins) {
                // If only 7 segments were specified
                if(segment < 0) continue;

                digitalWrite(segment, HIGH);

                size_t j = 0;
                for(auto digitState : state) {
                    digitalWrite(digit_pins[j++],(digitState & 1 << i) == 0);
                }

                // Give the segment some time to light up
                delayMicroseconds(light_time);

                j = 0;
                for(auto digitState : state) {
                    digitalWrite(digit_pins[j++], HIGH);
                }

                digitalWrite(segment, LOW);
                i += 1;
            }
        }

    private:
        uint8_t segment_pins[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
        uint8_t digit_pins[NUM_DIGITS];

        uint8_t state[NUM_DIGITS];
};

} // namespace SegmentDisplay

#endif // _SEGMENT_DISPLAY