NOTUA NV-FS1 Plus Fan

/**************************************************************************
 NOTua Desktop Fan V2

 Concept: numpty-in-training - https://www.thingiverse.com/thing:6752850 - September 03, 2024
 Portions of this code by David Johnson-Davies - http://www.technoblogy.com/show?2G8T

 Schematic & PCB at https://www.hackster.io/john-bradnam/contact-digital-thermometer-ed18d2
 
 2024-10-04 John Bradnam (jbrad2089@gmail.com)
   Create program for ATtiny3224

 --------------------------------------------------------------------------
 Arduino IDE:
 --------------------------------------------------------------------------
  BOARD: ATtiny3224/1614/1604/814/804/414/404/214/204
  Chip: ATtiny3224
  Clock Speed: 20MHz
  millis()/micros(): "Enabled (default timer)"
  Programmer: jtag2updi (megaTinyCore)

  ATTiny1614/3224 Pins mapped to Ardunio Pins
 
              +--------+
          VCC + 1   14 + GND
  (SS)  0 PA4 + 2   13 + PA3 10 (SCK)
        1 PA5 + 3   12 + PA2 9  (MISO)
  (DAC) 2 PA6 + 4   11 + PA1 8  (MOSI)
        3 PA7 + 5   10 + PA0 11 (UPDI)
  (RXD) 4 PB3 + 6    9 + PB0 7  (SCL)
  (TXD) 5 PB2 + 7    8 + PB1 6  (SDA)
              +--------+
  
 **************************************************************************/

#include <OneWire.h>
#include <U8g2lib.h>
#include <TimeLib.h>
#include <DS1302RTC.h>
//#include <EEPROM.h>
#include "Button.h"

#define TEMPERATURE_TIME 15000
#define FAN_TIME 200

#define FAN_PIN 0     //PA4
#define SW_PIN 1      //PA5
#define GND_PIN 2     //PA6
#define EN_PIN 3      //PA7
#define TEMP_PIN 4    //PB3
#define TXD_PIN 5     //PB2
#define SDA_PIN 6     //PB1
#define SCL_PIN 7     //PB0
#define SCLK_PIN 8    //PA1
#define IO_PIN 9      //PA2
#define CS_PIN 10     //PA3

#define TEMP_PORT PORTB
#define TEMP_BM PIN3_bm

U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);
DS1302RTC rtc(CS_PIN, IO_PIN, SCLK_PIN);

//Modes
enum modeEnum { FAN_MODE, HOUR_MODE, MIN_MODE };
modeEnum currentMode = FAN_MODE;
#define FLASH_TIMEOUT 200
unsigned long setFlash;
bool setColon;
int setHour;
int setMinute;

//Define buttons
enum ButtonEnum { STOP_BTN, UP_BTN, DOWN_BTN };
Button stopButton; 
Button upButton; 
Button downButton; 
//Forward references
void stopButtonPressed(void);
void upButtonPressed(void);
void downButtonPressed(void);

// Here you can define your voltagedivider from the boostconverter output
#define REFERENCE_VOLTAGE 5.0
#define R2 20000
#define R3 3300
#define VMAX 19
#define VMIN 4

bool fanEnabled = false;
float lastBoostVoltage = 0.0;
unsigned long fanUpdate = 0;
int lastFanSpeed = 0;


tmElements_t newTime;           //Used to store new time
int lastSeconds = -1;

unsigned long temperatureUpdate = 0;
int currentTemperature = 0;

char line1[32]; 
char line2[32]; 

//--------------------------------------------------------------------
// One Wire Protocol 
//--------------------------------------------------------------------

#define READ_ROM 0x33
#define MATCH_ROM 0x55
#define SKIP_ROM 0xCC
#define CONVERT_T 0x44
#define READ_SCRATCH_PAD 0xBE

// Buffer to read data or ROM code
static union {
  uint8_t DataBytes[9];
  unsigned int DataWords[4];
};

//-------------------------------------------------------------------------
// Initialise Hardware
//-------------------------------------------------------------------------

void setup(void)
{
  pinMode(EN_PIN,OUTPUT);
  digitalWrite(EN_PIN,LOW);
  pinMode(FAN_PIN,INPUT);
  
  OneWireSetup();

  //Initialise Buttons
  stopButton = Button(STOP_BTN, SW_PIN, 600, 699);
  upButton = Button(UP_BTN, SW_PIN, 400, 599);
  upButton.Repeat(upButtonPressed);
  downButton = Button(DOWN_BTN, SW_PIN, 0, 100);
  downButton.Repeat(downButtonPressed);
  
  u8g2.begin();
  u8g2.clearBuffer();         // clear the internal memory
  u8g2.sendBuffer();          // transfer internal memory to the display

  setSyncProvider(rtc.get);          // the function to get the time from the RTC
  if(timeStatus() != timeSet)
  {
    u8g2.drawStr(20,14,"RTC Sync Bad");   // x,y,text
    delay(2000);
    newTime.Year = CalendarYrToTm(2024);
    newTime.Month = 10;
    newTime.Day = 01;
    newTime.Hour = 14;
    newTime.Minute = 53;
    newTime.Second = 0;
    time_t t = makeTime(newTime);
    setTime(t);
    rtc.set(t);
    
    if (rtc.set(t) != 0) 
    {
      u8g2.drawStr(8,29,"Set Time Failed");
      delay(2000);
    }
  }
  
  newTime.Year = CalendarYrToTm(year());
  newTime.Month = month();
  newTime.Day = day();
  newTime.Hour = hour();
  newTime.Minute = minute();
  newTime.Second = second();
  
  showSplashScreen();
  setFlash = millis() + FLASH_TIMEOUT;
  
}

//--------------------------------------------------------------------
// Main program loop
//--------------------------------------------------------------------

void loop(void)
{
  bool force = false;
  
  //Callback will be invoked when up or down button is pressed
  upButton.Pressed();
  downButton.Pressed();

  //Timer for reading temperature
  if (millis() >= temperatureUpdate)
  {
    temperatureUpdate = millis() + TEMPERATURE_TIME;
    currentTemperature = readTemperature();
    force = true;
  }

  //Timer for reading temperature
  if (millis() >= fanUpdate)
  {
    fanUpdate = millis() + FAN_TIME;
    int fanSpeed = readFanSpeed();
    force = force || (lastFanSpeed != fanSpeed);
    lastFanSpeed = fanSpeed;
  }

  //Timer for flashing digits in set time modes
  if (millis() >= setFlash)
  {
    setColon = !setColon;
    setFlash = millis() + FLASH_TIMEOUT;
    force = true;
  }

  //Get short/long press on stop button
  //Long press goes straight to set hour mode
  PressEnum sw = stopButton.TimedPress(true);
  while (force || sw != NOT_DOWN || stopButton.IsDown())
  {
    switch (currentMode)
    {
      case FAN_MODE:
        if (sw == LONG_PRESS)
        {
          currentMode = HOUR_MODE; 
          setColon = true;
          setHour = hour();
          setMinute = minute();
        }
        else if (sw == SHORT_PRESS)
        {
          fanEnabled = !fanEnabled;
          digitalWrite(EN_PIN,(fanEnabled) ? HIGH : LOW);
          updateMainScreen(true);
        }
        else
        {
          updateMainScreen(force);
        }
        break;
        
      case HOUR_MODE:
        refreshTime(setHour, setMinute, setColon, true);
        
        if (sw == SHORT_PRESS)
        {
          currentMode = MIN_MODE; 
          setFlash = millis() + FLASH_TIMEOUT;
        }
        break;
        
      case MIN_MODE:
        refreshTime(setHour, setMinute, true, setColon);
        
        if (sw == SHORT_PRESS)
        {
          currentMode = FAN_MODE; 
          if (newTime.Hour != setHour || newTime.Minute != setMinute)
          {
            newTime.Hour = setHour;
            newTime.Minute = setMinute;
            time_t t = makeTime(newTime);
            setTime(t);
            rtc.set(t);
          }
          updateMainScreen(true);
        }
        break;
    }
    //Disable Stop button
    sw = NOT_DOWN;
    
    //Callback will be invoked when up or down button is pressed
    upButton.Pressed();
    downButton.Pressed();
    force = false;
  }
}  

//--------------------------------------------------------------------
// Show splash screen
//--------------------------------------------------------------------

void showSplashScreen()
{
  u8g2.setFont(u8g2_font_helvB12_tr); // helvetica bold
    
  //Splash screen 1
  u8g2.clearBuffer();
  u8g2.drawStr(16,14,"ATtiny3224");   // x,y,text
  u8g2.drawStr(8,29,"Desktop Fan");
  u8g2.sendBuffer();                // transfer internal memory to the display
  delay(3000);

  updateMainScreen(true);
}

//---------------------------------------------------------------
// Update display every second
//  force - always show time even if 1 second has not passed
//---------------------------------------------------------------

void updateMainScreen(bool force)
{
  force = force || (lastSeconds != second());
  if (force) 
  {
    u8g2.clearBuffer();
    
    //Time
    u8g2.setFont(u8g2_font_helvB24_tr);
    lastSeconds = second();
    int h = hour();
    //h = (h == 0) ? 12 : (h > 12) ? h - 12 : h;
    showTime(h, minute(), true, true, (second() & 0x01));

    //Temperature
    showTemperature(currentTemperature);
    
    //Fan speed
    showFanSpeed();
    
    u8g2.sendBuffer();
  }
}

//---------------------------------------------------------------
// Update display when setting time
//  h - hour
//  m - minute
//  he - hour enable 
//  me - minute enable 
//---------------------------------------------------------------

void refreshTime(int h, int m, bool he, bool me)
{
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_inb24_mf);
  showTime(h, m, he, me, true);
  u8g2.sendBuffer();
}

//---------------------------------------------------------------
// Handle UP btton
//---------------------------------------------------------------

void upButtonPressed()
{
  switch(currentMode)
  {
    case HOUR_MODE: 
      setHour = (setHour + 1) % 24;
      refreshTime(setHour, setMinute, true, true);
      break;
      
    case MIN_MODE: 
      setMinute = (setMinute + 1) % 60;
      refreshTime(setHour, setMinute, true, true);
      break;

    default:
      break;
  }
}  

//---------------------------------------------------------------
// Handle UP btton
//---------------------------------------------------------------

void downButtonPressed()
{
  switch(currentMode)
  {
    case HOUR_MODE: 
      setHour = (setHour + 24 - 1) % 24;
      refreshTime(setHour, setMinute, true, true);
      break;
      
    case MIN_MODE: 
      setMinute = (setMinute + 60 - 1) % 60;
      refreshTime(setHour, setMinute, true, true);
      break;

    default:
      break;
  }
}  

//---------------------------------------------------------------
// Update the temperature in the display buffer
// temp - deg in celsius (-1 for err 1, -2 for err 2)
//---------------------------------------------------------------

void showTemperature(int temp)
{
  int width;

  line1[0] = '\0';
  line2[0] = '\0';
  if (temp == -1) 
  {
    strcat(line1,"Er1");
  } 
  else if (temp == -2) 
  {
    strcat(line1,"Er2");
  }
  else
  {
    //int fahrenheit = (temp * 9) / 5 + 32;
    sprintf(line1,"%dC",temp);
  }

  u8g2.setFont(u8g2_font_helvB12_tr); // helvetica bold
  width = u8g2.getStrWidth(line1);
  u8g2.drawStr(128-width,14,line1);
}

//---------------------------------------------------------------
// Update the fan speed in the display buffer
//---------------------------------------------------------------

void showFanSpeed()
{
  int fanSpeed = readFanSpeed();
  if (fanSpeed == -1)
  {
    strcpy(line1,"OFF");
  }
  else
  {
    sprintf(line1,"%d%%",fanSpeed);
  }
  u8g2.setFont(u8g2_font_helvB12_tr); // helvetica bold
  int width = u8g2.getStrWidth(line1);
  u8g2.drawStr(128-width,31,line1);
}

//---------------------------------------------------------------
// Update the time in the display buffer
//  h - hour
//  m - minute
//  he - hour enable 
//  me - minute enable 
//  ce - colon enable 
//---------------------------------------------------------------

void showTime(int h, int m, bool he, bool me, bool ce)
{
  ce = true;
  char c = (ce) ? ':' : ' ';
  if (he)
  {
    if (me)
    {
      sprintf(line1,"%02d%c%02d",h,c,m);
    }
    else
    {
      sprintf(line1,"%02d%c  ",h,c);
    }
  }
  else
  {
    if (me)
    {
      sprintf(line1,"  %c%02d",c,m);
    }
    else
    {
      sprintf(line1,"  %c  ",c);
    }
  }
  
  u8g2.clearBuffer();
  //unsigned int width = u8g2.getStrWidth(line1);
  int height = u8g2.getAscent();
  int x = 0; //max((u8g2.getDisplayWidth() - width) / 2,0);
  int y = u8g2.getDisplayHeight() - max((u8g2.getDisplayHeight() - height) / 2,0);
  u8g2.drawStr(x,y,line1);
  //u8g2.drawFrame(0, 0, u8g2.getDisplayWidth(), u8g2.getDisplayHeight());
  //u8g2.sendBuffer();
}

//---------------------------------------------------------------
// Read the temperature
//  returns Temp in celsious
//          -1 - One wire reset failure
//          -2 - CRC failure
//---------------------------------------------------------------

int readTemperature()
{
  if (OneWireReset() != 0) 
  {
    return -1;
  } 
  else 
  {
    OneWireWrite(SKIP_ROM);
    OneWireWrite(CONVERT_T);
    while (OneWireRead() != 0xFF);
    OneWireReset();
    OneWireWrite(SKIP_ROM);
    OneWireWrite(READ_SCRATCH_PAD);
    OneWireReadBytes(9);
    if (OneWireCRC(9) == 0) 
    {
      int temp = DataWords[0];
      int celsius = (temp+8) >> 4;        // Round to nearest degree
      return celsius;
    } 
    else
    {
      return -2;
    }
  }
}

//---------------------------------------------------------------
// Read the fan speed
//  returns Fan speed as a percentage
//          -1 - Fan off
//---------------------------------------------------------------

int readFanSpeed()
{
  if (fanEnabled)
  {
    // Read the analog input (0 - 1023)
    int analogValue = analogRead(FAN_PIN);     
  
    // Convert the analog reading to a voltage (0 - 3.3V)
    float vIn = analogValue * (REFERENCE_VOLTAGE / 1023.0);  
  
    // Calculate the input voltage using the voltage divider formula
    // use the two const values to give it a litte Low-pass filter
    float voltageBoostconverter = 0.4*(vIn * ((R2 + R3) / R3))+ 0.6 * lastBoostVoltage;
    
    int fanSpeed = mapFanPower(voltageBoostconverter, VMIN, VMAX, 0.0, 100.0);
    lastBoostVoltage = voltageBoostconverter;
    return fanSpeed;
  }
  else
  {
    return -1;
  }
}

// calculate the fan speed in %
int mapFanPower(float x, float in_min, float in_max, float out_min, float out_max) 
{
  int result = (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
  if( result < out_min) 
  {
    result = out_min;
  }
  if (result > out_max) 
  {
    result = out_max;
  }
  return result;
}

//--------------------------------------------------------------------
// One Wire Protocol 
//--------------------------------------------------------------------

inline void PinLow () 
{
  TEMP_PORT.DIRSET = TEMP_BM;
  TEMP_PORT.OUTCLR = TEMP_BM;
}

inline void PinRelease () 
{
  TEMP_PORT.DIRCLR = TEMP_BM;
}

// Returns 0 or 1
inline uint8_t PinRead () 
{
  return (TEMP_PORT.IN & TEMP_BM) ? 1 : 0;
}

void DelayMicros(unsigned int micro) 
{
  delayMicroseconds(micro);
}

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

void OneWireSetup() 
{
}

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();
  }
}

// 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;
}