/* Four Channel Thermometer v3

   David Johnson-Davies - www.technoblogy.com - 5th December 2020
   ATtiny85 @ 8 MHz (internal oscillator; BOD disabled)
   
   CC BY 4.0
   Licensed under a Creative Commons Attribution 4.0 International license: 
   http://creativecommons.org/licenses/by/4.0/
*/
#include <EEPROM.h>

// Pins

const int clk = 0;
const int data = 1;
const int dc = 2;
const int cs = 3;

// One Wire Protocol **********************************************

// Buffer to read data or ROM code

uint8_t DataBytes[9];

const int OneWirePin = 4;

const int ReadROM = 0x33;
const int MatchROM = 0x55;
const int SkipROM = 0xCC;
const int ConvertT = 0x44;
const int ReadScratchpad = 0xBE;

inline void PinLow () {
  DDRB = DDRB | 1<<OneWirePin;
}

inline void PinRelease () {
  DDRB = DDRB & ~(1<<OneWirePin);
}

// Returns 0 or 1
inline uint8_t PinRead () {
  return PINB>>OneWirePin & 1;
}

void DelayMicros (int micro) {
  TCNT1 = 0; TIFR = 1<<OCF1A;
  OCR1A = (micro>>1) - 1;
  while ((TIFR & 1<<OCF1A) == 0);
}

void LowRelease (int low, int high) {
  PinLow();
  DelayMicros(low);
  PinRelease();
  DelayMicros(high);
}

uint8_t OneWireSetup () {
  TCCR1 = 0<<CTC1 | 0<<PWM1A | 5<<CS10;  // CTC mode, 500kHz clock
  GTCCR = 0<<PWM1B;
 }

uint8_t OneWireReset () {
  uint8_t data = 1;
  LowRelease(480, 70);
  data = PinRead();
  DelayMicros(410);
  return data;                         // 0 = device present
}

void OneWireWrite (uint8_t data) {
  int del;
  for (int i = 0; i<8; i++) {
    if ((data & 1) == 1) del = 6; else del = 60;
    LowRelease(del, 70 - del);
    data = data >> 1;
  }
}

uint8_t OneWireRead () {
  uint8_t data = 0;
  for (int i = 0; i<8; i++) {
    LowRelease(6, 9);
    data = data | PinRead()<<i;
    DelayMicros(55);
  }
  return data;
}

// Read bytes into array, least significant byte first
void OneWireReadBytes (int bytes) {
  for (int i=0; i<bytes; i++) {
    DataBytes[i] = OneWireRead();
  }
}

// Write bytes from array, least significant byte first
void OneWireWriteBytes (int bytes) {
  for (int i=0; i<bytes; i++) {
     OneWireWrite(DataBytes[i]);
  }
}

// Calculate CRC over buffer - 0x00 is correct
uint8_t OneWireCRC (int bytes) {
  uint8_t crc = 0;
  for (int j=0; j<bytes; j++) {
    crc = crc ^ DataBytes[j];
    for (int i=0; i<8; i++) crc = crc>>1 ^ ((crc & 1) ? 0x8c : 0);
  }
  return crc;
}

// EEPROM handling **********************************************

// Write 8 bytes from buffer to EEPROM
void EepromSave (int slot) {
  for (int i=0; i<8; i++) EEPROM.update(slot*8+i, DataBytes[i]);
}

// Read 8 bytes from EEPROM to buffer - return CRC
int EepromLoad (int slot) {
  for (int i=0; i<8; i++) DataBytes[i] = EEPROM.read(slot*8+i);
  return OneWireCRC(8);
}

// Compare 8 bytes from EEPROM with buffer - return true/false
boolean EepromCompare (int slot) {
  boolean equal = true;
  for (int i=0; i<8; i++) equal = equal && (DataBytes[i] == EEPROM.read(slot*8+i));
  return equal;
}

// Clear the EEPROM slots
void EepromClear () {
  for (int i=0; i<8; i++) DataBytes[i] = 0xff;
  for (int i=0; i<4; i++) EepromSave(i);
}

// OLED 128 x 32 monochrome display **********************************************

// Initialisation sequence for OLED module
int const InitLen = 24;
const unsigned char Init[InitLen] PROGMEM = {
  0xAE, // Display off
  0xD5, // Set display clock
  0x80, // Recommended value
  0xA8, // Set multiplex
  0x1F,
  0xD3, // Set display offset
  0x00,
  0x40, // Zero start line
  0x8D, // Charge pump
  0x14,
  0x20, // Memory mode
  0x01, // Vertical addressing
  0xA1, // 0xA0/0xA1 flip horizontally
  0xC8, // 0xC0/0xC8 flip vertically
  0xDA, // Set comp ins
  0x02,
  0x81, // Set contrast
  0x7F, // 0x00 to 0xFF
  0xD9, // Set pre charge
  0xF1,
  0xDB, // Set vcom detect
  0x40,
  0xA6, // Normal (0xA7=Inverse)
  0xAF  // Display on
};

// Write a data byte to the display
void Data(uint8_t d) {  
  uint8_t changes = d ^ (d>>1);
  PORTB = PORTB & ~(1<<data);
  for (uint8_t bit = 0x80; bit; bit >>= 1) {
    PINB = 1<<clk; // clk low
    if (changes & bit) PINB = 1<<data;
    PINB = 1<<clk; // clk high
  }
}

// Write a command byte to the display
void Command(uint8_t c) { 
  PINB = 1<<dc; // dc low
  Data(c);
  PINB = 1<<dc; // dc high
}

void InitDisplay () {
  PINB = 1<<cs; // cs low
  for (uint8_t c=0; c<InitLen; c++) Command(pgm_read_byte(&Init[c]));
  PINB = 1<<cs; // cs high
}

// Graphics **********************************************

int Scale = 1; // 2 for big characters
boolean Smooth = true;

// Character set for text (only capitals) - stored in program memory
const uint8_t CharMap[65][6] PROGMEM = {
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, 
{ 0x00, 0x00, 0x5F, 0x00, 0x00, 0x00 }, 
{ 0x00, 0x07, 0x00, 0x07, 0x00, 0x00 }, 
{ 0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00 }, 
{ 0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00 }, 
{ 0x23, 0x13, 0x08, 0x64, 0x62, 0x00 }, 
{ 0x36, 0x49, 0x56, 0x20, 0x50, 0x00 }, 
{ 0x00, 0x08, 0x07, 0x03, 0x00, 0x00 }, 
{ 0x00, 0x1C, 0x22, 0x41, 0x00, 0x00 }, 
{ 0x00, 0x41, 0x22, 0x1C, 0x00, 0x00 }, 
{ 0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x00 }, 
{ 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00 }, 
{ 0x00, 0x80, 0x70, 0x30, 0x00, 0x00 }, 
{ 0x08, 0x08, 0x08, 0x08, 0x08, 0x00 }, 
{ 0x00, 0x00, 0x60, 0x60, 0x00, 0x00 }, 
{ 0x20, 0x10, 0x08, 0x04, 0x02, 0x00 }, 
{ 0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00 }, 
{ 0x00, 0x42, 0x7F, 0x40, 0x00, 0x00 }, 
{ 0x72, 0x49, 0x49, 0x49, 0x46, 0x00 }, 
{ 0x21, 0x41, 0x49, 0x4D, 0x33, 0x00 }, 
{ 0x18, 0x14, 0x12, 0x7F, 0x10, 0x00 }, 
{ 0x27, 0x45, 0x45, 0x45, 0x39, 0x00 }, 
{ 0x3C, 0x4A, 0x49, 0x49, 0x31, 0x00 }, 
{ 0x41, 0x21, 0x11, 0x09, 0x07, 0x00 }, 
{ 0x36, 0x49, 0x49, 0x49, 0x36, 0x00 }, 
{ 0x46, 0x49, 0x49, 0x29, 0x1E, 0x00 }, 
{ 0x00, 0x00, 0x14, 0x00, 0x00, 0x00 }, 
{ 0x00, 0x40, 0x34, 0x00, 0x00, 0x00 }, 
{ 0x00, 0x08, 0x14, 0x22, 0x41, 0x00 }, 
{ 0x14, 0x14, 0x14, 0x14, 0x14, 0x00 }, 
{ 0x00, 0x41, 0x22, 0x14, 0x08, 0x00 }, 
{ 0x02, 0x01, 0x59, 0x09, 0x06, 0x00 }, 
{ 0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x00 }, 
{ 0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00 }, 
{ 0x7F, 0x49, 0x49, 0x49, 0x36, 0x00 }, 
{ 0x3E, 0x41, 0x41, 0x41, 0x22, 0x00 }, 
{ 0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00 }, 
{ 0x7F, 0x49, 0x49, 0x49, 0x41, 0x00 }, 
{ 0x7F, 0x09, 0x09, 0x09, 0x01, 0x00 }, 
{ 0x3E, 0x41, 0x41, 0x51, 0x73, 0x00 }, 
{ 0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00 }, 
{ 0x00, 0x41, 0x7F, 0x41, 0x00, 0x00 }, 
{ 0x20, 0x40, 0x41, 0x3F, 0x01, 0x00 }, 
{ 0x7F, 0x08, 0x14, 0x22, 0x41, 0x00 }, 
{ 0x7F, 0x40, 0x40, 0x40, 0x40, 0x00 }, 
{ 0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x00 }, 
{ 0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00 }, 
{ 0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00 }, 
{ 0x7F, 0x09, 0x09, 0x09, 0x06, 0x00 }, 
{ 0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00 }, 
{ 0x7F, 0x09, 0x19, 0x29, 0x46, 0x00 }, 
{ 0x26, 0x49, 0x49, 0x49, 0x32, 0x00 }, 
{ 0x03, 0x01, 0x7F, 0x01, 0x03, 0x00 }, 
{ 0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00 }, 
{ 0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00 }, 
{ 0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00 }, 
{ 0x63, 0x14, 0x08, 0x14, 0x63, 0x00 }, 
{ 0x03, 0x04, 0x78, 0x04, 0x03, 0x00 }, 
{ 0x61, 0x59, 0x49, 0x4D, 0x43, 0x00 }, 
{ 0x00, 0x7F, 0x41, 0x41, 0x41, 0x00 }, 
{ 0x02, 0x04, 0x08, 0x10, 0x20, 0x00 }, 
{ 0x00, 0x41, 0x41, 0x41, 0x7F, 0x00 }, 
{ 0x04, 0x02, 0x01, 0x02, 0x04, 0x00 }, 
{ 0x40, 0x40, 0x40, 0x40, 0x40, 0x00 },
{ 0x00, 0x06, 0x09, 0x06, 0x00, 0x00 } // degree symbol = '`'
};

void ClearDisplay () {
  PINB = 1<<cs; // cs low
  // Set column address range
  Command(0x21); Command(0); Command(127);
  // Set page address range
  Command(0x22); Command(0); Command(3);
  for (int i = 0 ; i < 128*4; i++) Data(0);
  PINB = 1<<cs; // cs high
}

// Converts bit pattern abcdefgh into aabbccddeeffgghh
int Stretch (int x) {
  x = (x & 0xF0)<<4 | (x & 0x0F);
  x = (x<<2 | x) & 0x3333;
  x = (x<<1 | x) & 0x5555;
  return x | x<<1;
}

// Plots a character; line = 0 to 2; column = 0 to 21
void PlotChar(char c, int line, int column) {
  PINB = 1<<cs; // cs low
  // Set column address range
  Command(0x21); Command(column*6); Command(column*6 + Scale*6 - 1);
  // Set page address range
  Command(0x22); Command(line); Command(line + Scale - 1);
  uint8_t col0 = pgm_read_byte(&CharMap[c-32][0]);
  int col0L, col0R, col1L, col1R;
  col0L = Stretch(col0);
  col0R = col0L;
  for (uint8_t col = 1 ; col < 5; col++) {
    uint8_t col1 = pgm_read_byte(&CharMap[c-32][col]);
    col1L = Stretch(col1);
    col1R = col1L;
    if (Scale == 1) Data(col0);
    // Smoothing
    else {
      if (Smooth) {
        for (int i=6; i>=0; i--) {
          for (int j=1; j<3; j++) {
            if (((col0>>i & 0b11) == (3-j)) && ((col1>>i & 0b11) == j)) {
              col0R = col0R | 1<<((i*2)+j);
              col1L = col1L | 1<<((i*2)+3-j);
            }
          }
        }
      }
      Data(col0L); Data(col0L>>8); 
      Data(col0R); Data(col0R>>8);
      col0L = col1L; col0R = col1R;
    }
    col0 = col1;
  }
  if (Scale == 1) Data(col0);
  else {
    Data(col0L); Data(col0L>>8); 
    Data(col0R); Data(col0R>>8); 
  } 
  PINB = 1<<cs; // cs high
}

char DigitChar (unsigned long number, unsigned long divisor) {
  return (number/divisor) % 10 + '0';
}

// Display a temperature from -99 deg C to 999 deg C starting at line, column
void PlotTemperature (int temp, int line, int column) {
  boolean dig = false;
  unsigned int j = 100;
  if (temp < 0) {
    PlotChar('-', line, column);
    temp = - temp;
    column = column + Scale;
    j = 10;
  }
  for (int d=j; d>0; d=d/10) {
    char c = DigitChar(temp, d);
    if (c == '0' && !dig) c = ' '; else dig = true;
    PlotChar(c, line, column);
    column = column + Scale;
  }
  PlotChar('`', line, column); column = column + Scale;
  PlotChar('C', line, column);
}

// Setup **********************************************

void setup() {
  // EepromClear();    
  pinMode(dc, OUTPUT); digitalWrite(dc,HIGH);
  pinMode(clk, OUTPUT); digitalWrite(clk,HIGH);
  pinMode(data, OUTPUT);
  pinMode(cs, OUTPUT); digitalWrite(cs,HIGH);
  InitDisplay();
  ClearDisplay();
  OneWireSetup();
  Scale = 2;
  // Check if there's something on the bus
  cli();
  if (OneWireReset() != 0) { PlotChar('?',1,10); for(;;); }
  int slot;
  // Find the first free EEPROM slot
  for (slot=0; slot<4; slot++) {
    if (EepromLoad(slot) != 0) break;
  }
  if (slot < 4) {
    // Try reading the ROM 
    OneWireWrite(ReadROM);
    OneWireReadBytes(8);
    sei();
    if (OneWireCRC(8) == 0) {
      // Check we haven't already got it
      int j;
      for (j=0; j<slot; j++) {
        if (EepromCompare(j)) break;
      }
      // Save it into the slot
      if (j == slot) EepromSave(slot);
    }
  }
}

void loop () {
  for (int i=0; i<4; i++) {
    int line = (i / 2)*2;
    int col = (i % 2)*11;
    // Display temperatures of all devices on bus
    cli();                            // No interrupts
    if (OneWireReset() != 0) {
      sei();
      PlotChar('?', line, col);
    } else if (EepromLoad(i) == 0) {      
      OneWireWrite(MatchROM);
      OneWireWriteBytes(8);
      OneWireWrite(ConvertT);
      while (OneWireRead() != 0xFF);
      OneWireReset();
      OneWireWrite(MatchROM);
      OneWireWriteBytes(8);
      OneWireWrite(ReadScratchpad);
      OneWireReadBytes(9);
      sei();                          // Interrupts
      if (OneWireCRC(9) == 0) {
        int temp = DataBytes[1]<<8 | DataBytes[0];
        PlotTemperature(temp>>4, line, col);
      } else PlotChar('X', line, col);
    }
  }
}