ttt2/my_src/hmi.c

/*
 * display.c
 *
 *  Created on: May 31, 2017
 *      Author: wn
 */


#include <hmi.h>
#include "stm32f1xx_hal.h"
#include "alarm.h"
#include <PontCoopScheduler.h>
#include "oled.h"
#include "eeprom.h"
#include "thermometer.h"



const uint8_t COLD_COUNT_THRESHOLD = 40;

const char THERMOMETER_STATE_MARKS[TE_LAST] = {'I', 'H', 'C', 'C', 'C', 'B'};



volatile tDisplay display = {
    .toggle = 0, .setModeTemperature = 0, .setModeTime = 0,
    .timerState = TT_IDLE,
    .thermometerEngineState = TE_IDLE,
    .setState = TS_IDLE,
    .targetTemperature = 80, .currentTemperature = 75,
    .targetTime = 120, .currentTime = 0,
    .overrunTime = 0,
    .operatingTime = 0
};




void updateDisplay(void *handle) {
  tDisplay *lDisplay = (tDisplay*) handle;
  lDisplay->toggle ^= 0x01;
  char buf[32];

  if (lDisplay->setModeTemperature && lDisplay->toggle) {
    sprintf(buf, "        %3d'C", lDisplay->currentTemperature);
  } else {
    sprintf(buf, "%3d'C   %3d'C", lDisplay->targetTemperature, lDisplay->currentTemperature);
  }
  LED_P8x16Str(0, 0, buf);

  if (lDisplay->setModeTime && lDisplay->toggle) {
    sprintf(buf, "        %3ds", lDisplay->currentTime);
  } else {
    sprintf(buf, "%3ds    %3ds", lDisplay->targetTime, lDisplay->currentTime);
  }
  LED_P8x16Str(0, 2, buf);


  sprintf(buf, "%c     %5ds", THERMOMETER_STATE_MARKS[lDisplay->thermometerEngineState], lDisplay->overrunTime);
//  static uint32_t h = 0;
//  static uint32_t c = 0;
//  uint32_t i = HAL_GetTick();
//  sprintf(buf, "%d %d %d", c, i, i-h);
//  h = i;
//  c++;
  LED_P8x16Str(0, 4, buf);

  sprintf(buf, "%d", lDisplay->operatingTime);
  LED_P8x16Str(0, 6, buf);
}

void thermometerEngine(void *handle) {
  tDisplay *lDisplay = (tDisplay*) handle;
  lDisplay->currentTemperature = thermometerGetValue();

  switch (lDisplay->thermometerEngineState) {
  case TE_IDLE:
    if (lDisplay->currentTemperature > lDisplay->targetTemperature) {
      lDisplay->thermometerEngineState = TE_HOT;
      lDisplay->coldCount = 0;
    }
    break;
  case TE_HOT:
    if (lDisplay->currentTemperature <= lDisplay->targetTemperature) {
      lDisplay->coldCount += 1;
    }
    if (lDisplay->coldCount >= COLD_COUNT_THRESHOLD) {
      lDisplay->thermometerEngineState = TE_COLD;
    }
    break;
  case TE_COLD:
    enableAlarm(TEMPERATURE_ALARM);
    lDisplay->thermometerEngineState = TE_UNCONFIRMED;
    break;
  case TE_UNCONFIRMED:
    break;
  case TE_CONFIRMED:
    disableAlarm();
    lDisplay->thermometerEngineState = TE_BLOCKED;
    break;
  case TE_BLOCKED:
    break;
  default:
    lDisplay->thermometerEngineState = TE_IDLE;
  }
}

static void thermometerEngineConfirmAlarmOrBlock() {
  if (display.thermometerEngineState == TE_UNCONFIRMED) {
    display.thermometerEngineState = TE_CONFIRMED;
  } else {
    display.thermometerEngineState = TE_BLOCKED;
  }
}

static void thermometerEngineUnblock() {
  display.thermometerEngineState = TE_IDLE;
}

void hmiInit() {
  if (! eepromReadStorage()) {
    eepromWriteStorage();
  }

  schAdd(thermometerEngine, &display, 0, 250);
  schAdd(updateDisplay, &display, 10, 250);
}

void clearSetMode(void *handle) {
  tDisplay *lDisplay = (tDisplay*) handle;
  lDisplay->setModeTemperature = 0;
  lDisplay->setModeTime = 0;
  lDisplay->setState = TS_SET_TEMPERATURE;
}

static void disableSetModeTimer() {
  schDel(clearSetMode, (void*)&display);
}

static void reEnableSetModeTimer() {
  schDel(clearSetMode, (void*)&display);
  schAdd(clearSetMode, (void*)&display, 10000, 0);
}

static void toggleSetMode() {
  switch (display.setState) {
  default:
  case TS_IDLE:
    disableSetModeTimer();
    display.setModeTemperature = 0;
    display.setModeTime = 0;
    display.setState = TS_SET_TEMPERATURE;
    break;
  case TS_SET_TEMPERATURE:
    reEnableSetModeTimer();
    display.setModeTemperature = 1;
    display.setModeTime = 0;
    display.setState = TS_SET_TIME;
    break;
  case TS_SET_TIME:
    reEnableSetModeTimer();
    display.setModeTemperature = 0;
    display.setModeTime = 1;
    display.setState = TS_IDLE;
    break;
  }
}

void displayIncValue() {
  if (display.setModeTemperature == 1) {
    reEnableSetModeTimer();
    if (display.targetTemperature < 100) {
      display.targetTemperature++;
      eepromWriteStorage();
    }
  }
  if (display.setModeTime == 1) {
    reEnableSetModeTimer();
    if (display.targetTime < 999) {
      display.targetTime += 10;
      eepromWriteStorage();
    }
  }
}

void displayDecValue() {
  if (display.setModeTemperature == 1) {
    reEnableSetModeTimer();
    if (display.targetTemperature > 0) {
      display.targetTemperature--;
      eepromWriteStorage();
    }
  }
  if (display.setModeTime == 1) {
    reEnableSetModeTimer();
    if (display.targetTime >= 10) {
      display.targetTime -= 10;
      eepromWriteStorage();
    }
  }
}

void buttonShort() {
  if (display.setModeTemperature == 1 || display.setModeTime == 1) {
    toggleSetMode();
  } else if (display.timerState == TT_IDLE) {
    startTimer();
    thermometerEngineConfirmAlarmOrBlock();
  } else if (display.timerState == TT_RUNNING || display.timerState == TT_OVERRUN) {
    stopTimer();
    thermometerEngineUnblock();
    disableAlarm();
  }
}

void buttonLong() {
  if (display.timerState == TT_IDLE) {
    toggleSetMode();
  }
}