hc.c

Go to the documentation of this file.

#include <math.h>
#include "types.h"
#include "hc.h"
#include "init.h"
#include "adc.h"
#include "lcdisp.h"
#include "timer.h"
#include "comm.h"
#include "setup.h"

// * nominal temperature in eeprom
// */

HCREC EEMEM ge_hcRec[NUM_HR];
UCHAR EEMEM ge_hcrCnt = 0;
UCHAR EEMEM e_dummy[3] = "..";
extern MEASSET EEMEM ge_msRec[NUM_MSR];
MEASSET g_sets[NUM_MS];
extern volatile CTRL_MODE g_ctm;
extern ENG_TIMER volatile g_et;

//remeber previous minute for period of time evaluation
UINT old_min = -IV_MEAS;

int main(void) {
//  /**
//   * nominal temperature from setup
//   */
//  UINT tNom = gNit();
  UINT innerTemp = INVALID_VAL_U16;
  UINT outerTemp = INVALID_VAL_U16;
  UINT supVolt = INVALID_VAL_U16;
  UINT forTemp = INVALID_VAL_U16;
  UCHAR firstTime = TRUE;
//  UCHAR btnOffFct = OFF_NEAR;
  UCHAR recCnt = 0;
  UCHAR idx=0;
  OP_MODE opm = OM_SHMEAS;
  BTN_CODE bc = BC_NONE;
  UCHAR old_sec=0;
  UCHAR old5sec=0;
  CHAR dSec=0;
  UINT time = 0;
//  /**
//   * running tenth of a second
//   */
//  extern UCHAR volatile g_s100;
  extern UCHAR volatile g_sec;
  extern UINT volatile g_min;
  MEASSET* set = NULL;
  CTRL_MODE oldCm = CM_DENY;
  UCHAR cmName[5];
  //record counter for MEASSETs
  UCHAR msrCnt = -1;
  //keep recent inner temp
  UINT pInTemp = 0;
  //keep calculated forerun from heating curve
  UINT cFor = 0;


  Init();
  recCnt = eeprom_read_byte(&ge_hcrCnt);
  //prepare old_min to be in sync for doing control
  old_min = -gIvMeas();
  // Global enable interrupts
  sei();
  
  while(TRUE) {
    //button decoding
    bc = DecodeButton(/*&btnOffFct*/);
    //temperature capturing
    forTemp = CalcAdcTemp(ADC_TMP_INNER_ID);
//    outerTemp = CalcAdcTemp(ADC_TMP_OUTER_ID);
    GetSenderValues(&innerTemp, &outerTemp/*, &supVolt*/);
    //respect inner temperature offset
    innerTemp += gOit();
    //override supply voltage by local measurement
    supVolt = CalcSupplyVoltage(ADC_TMP_OUTER_ID);
    //second changed
    if(old_sec != g_sec || firstTime) {
      time = g_min * 100 + g_sec;
      old_sec = g_sec;
      if(!(opm == OM_SETUP || opm == OM_SHMEAS)) {
        PrintValue(DT_TIME, 0, 1, NM_TIME, &time);
        if((forTemp != INVALID_VAL_U16) && (recCnt >= NUM_HR)) {
          PrintValue(DT_UINT, 8, 1, NM_TFOR, &forTemp);
        }
      }
    }
    if(opm == OM_CONTI || opm == OM_SENDER) {
      //serial communication (testing)
//      if(g_comDataReady) {
//        g_comDataReady = FALSE;
//        rcvBuf = ~FlipByte(USIBR); //received byte from USI buffer
//        if(rcvBuf != oldRcvBuf) {
//          PrintValue(DT_UCHAR, 8, 1, 'S', &rcvBuf);
//          oldRcvBuf = rcvBuf;
//        }
//      }
      //supply voltage printing
      if(opm == OM_SENDER && supVolt != INVALID_VAL_U16)
        PrintValue(DT_UINT, 8, 1, NM_VOLT, &supVolt);

      //temperature value printing
      if((innerTemp != INVALID_VAL_U16) && (outerTemp != INVALID_VAL_U16)) {
        pInTemp = innerTemp;
        PrintValue(DT_INT, 8, 0, NM_TOUT, &outerTemp);
//        if(opm == OM_SENDER)
//          //print all values from temperature sender
//          PrintValue(DT_UINT, 8, 1, NM_VOLT, &supVolt);
//        else
//        if(opm == OM_CONTI)
//          PrintValue(DT_UINT, 8, 1, NM_TFOR, &forTemp);
      }

      //alternating print inner temp and calculated forerun temp
      if((g_sec & 0x02) == 0)
        PrintValue(DT_INT, 0, 0, NM_TIN, &pInTemp);
      else
        PrintValue(DT_UINT, 0, 0, NM_TFOR, &cFor);
    }
    //temperature controlling and recording
    if(opm != OM_ENGTEST) {
      if((set = DoControl(innerTemp, outerTemp, forTemp, recCnt < NUM_HR, g_min, g_sec)) != NULL) {
//        DoRecord(&recCnt, set);
//        PrintMeasValues(set, opm, msrCnt >= NUM_MSR);
        cFor = set->forTemp;
        if((gMov() >= OVM_MSR) && ((msrCnt < NUM_MSR) || (msrCnt == (UCHAR)-1))) {
          if((++msrCnt) < NUM_MSR) {
            eeprom_write_block(set, &ge_msRec[msrCnt], sizeof(MEASSET));
            sMov(0);
          }
        }
      }
    }
    //print control mode
    if(opm == OM_TMPCTRL) {
      if(oldCm != g_ctm) {
        WriteCtrlMode(NM_CNT, GetCtrlMode(g_ctm, cmName));
        oldCm = g_ctm;
      }
    }
    //change operation mode when both buttons pressed
    if((opm != OM_SETUP) && (bc == BC_DNUP || firstTime)) {
      old5sec = g_sec;
      opm = SetLimitValue(opm, DT_UCHAR, DIR_UP, OM_TMPCTRL, OP_MODES - 2);
      PrintValue(DT_UCHAR, 8, 1, NM_OPMODE, &opm);
      if(opm == OM_TMPCTRL)
        WriteCtrlMode(NM_CNT, GetCtrlMode(g_ctm, cmName));
    }
    //engine test
    if(opm == OM_ENGTEST) {
      DoEngineTest(bc);
    }
    //meas value visualization
    else if(opm == OM_SHMEAS) {
      //write previous meas sets every n seconds
      //skip invalid data on current idx
      if(g_sets[idx].inTemp == INVALID_VAL_I16) {
//        idx = (UCHAR)SetLimitValue(idx, (CHAR)-1, 0, (INT)(NUM_MS - 1));
        if(--idx == (UCHAR)-1)
          idx = NUM_MS - 1;
      }
      dSec = g_sec - old5sec;
      if(g_sec == 0 && old5sec != 0)
        old5sec = gSmi();
      if(dSec == (CHAR)(gSmi()-(UCHAR)60) || (CHAR)gSmi() == dSec || firstTime) {
        old5sec = g_sec;
        PrintMeasValues(&(g_sets[idx]), opm, msrCnt < NUM_MSR);
        time = idx * gIvMeas() * 100;
        PrintValue(DT_TIME, 0, 1, NM_TIME, &time);
//        idx = (UCHAR)SetLimitValue(idx, (CHAR)-1, 0, (INT)(NUM_MS - 1));
        if(--idx == (UCHAR)-1)
          idx = NUM_MS - 1;
      }
    }
    DoSetup(bc, &opm);
//    TestButton(bc);
    firstTime = FALSE;
  }
}

MEASSET* DoControl(INT inTemp, INT outTemp, UINT forTemp, UCHAR learning, UINT min, UCHAR sec) {
  static UINT oldShdMin = 1;
  static UCHAR old_sec = -1,
      balDur=0, //balance counter (multiple of IV_MEAS)
      shtDn=0; //shut down counter (multiple of IV_MEAS)
  INT dMin = 0;
  UCHAR i=0/*, prevIdx=0*/;
  MEASSET* ret = NULL;

  dMin = min - old_min;
  dMin = dMin < 0 ? gIvMeas() : dMin;
  i = min/gIvMeas();
  //too warm outside?
  if(g_sets[i].outTemp >= (INT)(gSdt() + gDelTemp())) {
    g_ctm = CM_SHDN;
    g_et.em = EM_CW;
    if(oldShdMin != min) {
      ++shtDn;
      oldShdMin = min;
    }
  }
  else {
    //conditionally initiate new measurement and controlling cycle
    if((dMin >= gIvMeas()) && (g_ctm == CM_MEAS) && (inTemp != INVALID_VAL_U16) && (outTemp != INVALID_VAL_U16) && (forTemp != INVALID_VAL_U16)) {
      g_ctm = CM_DENY;
      old_min = min;
      g_sets[i].inTemp = inTemp;
      g_sets[i].outTemp = outTemp;
      g_sets[i].forTemp = forTemp;
//      oldNomTemp = gNit();
      old_sec = -1;
      ret = &g_sets[i];
    }
    else if(old_sec == (UCHAR)-1 && g_sets[i].outTemp <= (INT)(gSdt() - gDelTemp())) {
      g_et.allow = TRUE;
      g_et.cnt = 0;
      shtDn = 0;
      oldShdMin = 0;
      old_sec = sec;
      if(learning) {
        //too warm inside? inner temp deviation to nom greater than 0.2°C?
        if(gdInNom(g_sets[i].inTemp) > gDelTemp()) {
          g_et.em = EM_CW;
//          //did the nominal temperature change?
//          if(oldNomTemp != gNit()) {
//            //control down
//            g_et.em = EM_CW;
//          }
//          else {
//            //did the inner temp rise?
//            prevIdx = CalcPrevIndex(i, 1);
//            if((g_sets[prevIdx].inTemp != INVALID_VAL_I16) && (g_sets[prevIdx].inTemp >= (INT)MIN_ABS_INNER_TEMP)
//                && ((g_sets[i].inTemp - g_sets[prevIdx].inTemp) >= (INT)gDelTemp())) {
//              //valid previous data set? did the outer temp rise around a specific deviation in a specific time?
//              prevIdx = CalcPrevIndex(i, gTrd() / gIvMeas());
//              if((g_sets[prevIdx].outTemp != INVALID_VAL_I16) && ((g_sets[i].outTemp - g_sets[prevIdx].outTemp) >= (INT)(gTdm() * gDelTemp())))
//                //control down
//                g_et.em = EM_CW;
//            }
//          }
        }
        else if(gdInNom(g_sets[i].inTemp) < -gDelTemp()) {
          //too cold?
          g_et.em = EM_CCW;
        }
        else {
          //allow recording of heating curve if long enough in balance
          if(balDur >= gHci()) {
            balDur = 0;
            g_ctm = CM_REC;
          }
          else
            ++balDur;
          ret = &g_sets[i];
        }
      }
      //leading the forerun temp
      else if(g_sets[i].forTemp > MIN_FOR_TEMP && g_sets[i].forTemp < MAX_FOR_TEMP) {
        g_ctm = CM_FOR;
        if((forTemp = FindForeRun(&g_sets[i].outTemp, NUM_HR, MAX_DEL_OUTER_TEMP)) != INVALID_VAL_U16) {
          if(g_sets[i].forTemp < forTemp - DEL_FOR_TEMP)
            //too cold?
            g_et.em = EM_CCW;
          else if(g_sets[i].forTemp > forTemp + DEL_FOR_TEMP)
            //control down
            g_et.em = EM_CW;
          g_sets[i].forTemp = forTemp;
          ret = &g_sets[i];
        }
      }
    }
  }
  if(shtDn > gSdd()) {
    g_et.em = EM_STOP;
    shtDn = gSdd() + 1;
  }
  ControlEngine(g_et.em);
  return ret;
}

UINT FindForeRun(INT* outTemp, const UCHAR range, UINT const delLim) {
  UCHAR i=0;
  HCREC rec;
  INT dOut = 0;

  for(i=0;i<range;++i) {
    eeprom_read_block(&rec, &ge_hcRec[i], sizeof(HCREC));
    dOut = *outTemp - rec.outTemp;
//    if(dOut >= 0 ? (dOut <= delLim/*MAX_DEL_OUTER_TEMP*/) : (dOut >= -delLim/*-MAX_DEL_OUTER_TEMP*/)) {
    if(abs(dOut) <= delLim) {
      *outTemp = rec.outTemp;
      return rec.forTemp;
    }
  }
  return INVALID_VAL_U16;
}

//void DoRecord(UCHAR* recCnt, MEASSET* set) {
//  HCREC hcr;
//
//  if(set == NULL) return;
//  if(g_ctm == CM_REC) {
//    g_ctm = CM_DENY;
//    *recCnt = eeprom_read_byte(&ge_hcrCnt);
//    //still some space in eep and set of values does not exist?
//    if(*recCnt < NUM_HR && FindForeRun(&set->outTemp, *recCnt, MAX_DEL_OUTER_TEMP) == INVALID_VAL_U16) {
//      hcr.outTemp = set->outTemp;
//      hcr.forTemp = set->forTemp;
//      eeprom_write_block(&hcr, &ge_hcRec[*recCnt], sizeof(HCREC));
//      eeprom_write_byte(&ge_hcrCnt, ++(*recCnt));
//    }
//  }
//}

void ControlEngine(ENG_MODE em) {
  switch(em)
  {
  case EM_STOP:
    ENG_STOP_CW;
    ENG_STOP_CCW;
    break;
  case EM_CW:
    ENG_RUN_CW;
    ENG_STOP_CCW;
    break;
  case EM_CCW:
    ENG_STOP_CW;
    ENG_RUN_CCW;
    break;
  }
}

void PrintMeasValues(MEASSET* ms, OP_MODE opm, UCHAR msrFull) {
//  static UCHAR oldRecCnt = -1;
//  INT dInNom = 0;

  if(opm == OM_SETUP) return;
  PrintValue(DT_INT, 0, 0, msrFull ? NM_MSRFULL : NM_TIN, &ms->inTemp);
  PrintValue(DT_INT, 8, 0, msrFull ? NM_MSRFULL : NM_TOUT, &ms->outTemp);
  if(opm == OM_SHMEAS)
    PrintValue(DT_UINT, 8, 1, msrFull ? NM_MSRFULL : NM_TFOR, &ms->forTemp);
//  else {
//    dInNom = gdInNom(ms->inTemp);
//    PrintValue(DT_INT, 0, 1, NM_TDINNOM, &dInNom/*ms->dInNom*/);
//    if(g_ctm == CM_FOR)
//      PrintValue(DT_UINT, 0, 0, NM_TFOR, &ms->forTemp);
//  }
}

void PrintValue(DATTYPE dt, UCHAR col, UCHAR row, UCHAR name, void* value) {
  MEASVAL mv;

  mv.dt = dt;
  mv.pos.col = col;
  mv.pos.row = row;
  mv.name = name;
  mv.value = value;
  WriteMeasVal(&mv);
}

void DoEngineTest(BTN_CODE bc) {
  static ENG_MODE engMod = EM_STOP;

  if((bc != BC_NONE && bc != BC_DNUP)) {
    if(engMod == EM_CW || engMod == EM_CCW)
      engMod = EM_STOP;
    else {
      switch(bc) {
      case BC_DN:
        engMod = EM_CW;
        break;
      case BC_UP:
        engMod = EM_CCW;
        break;
      default:
        break;
      }
    }
    ControlEngine(engMod);
  }
}

UCHAR CalcPrevIndex(UCHAR curIdx, UCHAR delIdx) {
  CHAR prevIdx=0;

  prevIdx = (CHAR)(curIdx - delIdx);
  if(prevIdx < 0)
    prevIdx += NUM_MS;
  return (UCHAR)prevIdx;
}