zlog.h

Go to the documentation of this file.

// ***************************************************************************
//                        zlog.h
//                           -------------------
//
//
//    copyright            : (c) 2004 Tim Baier
//    email                : tbaier@informatik.uni-hamburg.de
// ***************************************************************************

#ifndef ZLOG_H
#define ZLOG_H

#include <stdlib.h>
#include <string>
#include <iostream>

#define DEFAULT_LOG_SIZE 10

class ZLog
{
  public:

    ZLog();

    ZLog(const int logsize);

    ~ZLog();

    void writeLog(const short value);

    short getLog(const int pos) const;

    short getLastLog() const;

    void setSize(const int size);

    void eraseLog();

    void setLog(const short value);

    void resetLog();

    void showLog();

 protected:

 //   struct LogPos{
 //     int Pos;
 //     short Value;
 //   }MinLog, MaxLog;

    void detectTorqueSwitch();

  //  void initMinMax();
   // void setMinMax(const short value);

    short *Log;

    int ActPos;

    int LogSize;
};



// ************************
// **                    **
// ************************
inline void ZLog::writeLog(const short value)
{
  if(++ActPos >= LogSize)
    ActPos = 0;

  Log[ActPos] = value;
  //setMinMax(value);

  detectTorqueSwitch();
}


// ************************
// **                    **
// ************************
#if 0
inline void ZLog::setMinMax(const short value)
{
  if(value <= MinLog.Value){
    MinLog.Value = value;
    MinLog.Pos   = ActPos;
  }

  if(value >= MaxLog.Value){
    MaxLog.Value = value;
    MaxLog.Pos   = ActPos;
  }
}
#endif
#if 0
// ************************
// **                    **
// ************************
inline void ZLog::detectTorqueSwitch()
{
  int dummy = ActPos;
  int dummy1 = (--dummy < 0) ? dummy = LogSize-1 : dummy;

  if(((Log[ActPos] - Log[dummy1]) > 3)){
    int dummy2 = (--dummy < 0) ? dummy = LogSize-1 : dummy;
    int dummy3 = (--dummy < 0) ? dummy = LogSize-1 : dummy;
    int dummy4 = (--dummy < 0) ? dummy = LogSize-1 : dummy;

    if(Log[dummy1] < Log[dummy2] && Log[dummy2] <= Log[dummy3]){

      if((Log[ActPos] < Log[dummy3]) && (Log[dummy3] - Log[dummy1]) > 14 &&
         (Log[dummy4] < Log[dummy3])){

        std::cout << "****************************** TORQUE SWITCH ACTIVATED?" << std::endl;
        showLog();
      }
    }
    else{

      if((Log[dummy2] - Log[dummy1]) > 10 &&
         //(Log[dummy1] < Log[dummy3]) &&
         (Log[dummy3] < Log[dummy2])){

        std::cout << "****************************** TORQUE SWITCH ACTIVATED ELSE?" << std::endl;
        showLog();
      }
    }
  }
}
#endif


// ************************
// **                    **
// ************************
inline void ZLog::detectTorqueSwitch()
{
  int dummy = ActPos;
  int dummy1 = (--dummy < 0) ? dummy = LogSize-1 : dummy;
  int dummy2 = (--dummy < 0) ? dummy = LogSize-1 : dummy;

  if( (Log[ActPos] - Log[dummy2]) > 6 && abs(Log[dummy1] - Log[ActPos]) > 2){
    int dummy3 = (--dummy < 0) ? dummy = LogSize-1 : dummy;
    int dummy4 = (--dummy < 0) ? dummy = LogSize-1 : dummy;
    int dummy5 = (--dummy < 0) ? dummy = LogSize-1 : dummy;

    if(Log[dummy2] < Log[dummy3] && Log[dummy3] <= Log[dummy4]){
      if((Log[dummy4] - Log[dummy2]) > 16 &&
         (Log[dummy4] - Log[dummy5]) > 3){
        std::cout << "****************************** TORQUE SWITCH ACTIVATED?" << std::endl;
        showLog();
      }
    }
    else{
      if((Log[dummy3] - Log[dummy2]) > 13 &&
         //(Log[dummy1] < Log[dummy3]) &&
         ((Log[dummy3] - Log[dummy4]) >= 3 )){
        std::cout << "****************************** TORQUE SWITCH ACTIVATED ELSE?" << std::endl;
        showLog();
      }
    }
  }
}



// ************************
// **                    **
// ************************
inline short ZLog::getLog(int pos) const
{
  if(pos > LogSize)
    exit(-100);
  else
    return Log[pos];
}

// ************************
// **                    **
// ************************
inline short ZLog::getLastLog() const
{
  return Log[ActPos];
}


// ************************
// **                    **
// ************************
inline void ZLog::eraseLog()
{
  memset(Log, 0, sizeof(Log));
}


// ************************
// **                    **
// ************************
inline void ZLog::setLog(const short value)
{
  for(int i = LogSize-1; i >= 0; i--)
    Log[i] = value;
}


// ************************
// **                    **
// ************************
inline void ZLog::resetLog()
{
  ActPos = 0;
}


// ************************
// **                    **
// ************************
inline void ZLog::showLog()
{
  int pos = ActPos;
  std::cout << " ** Log :" << std::endl;
  std::cout << "         " << Log[pos--] << std::endl;
  while(pos != ActPos){
    if(pos < 0)
      pos = LogSize-1;

     std::cout << "         " << Log[pos--] << std::endl;
   }
}

#endif //ZLOG_H

---

Tim Baier bhandlib v0.25

Generated Wed Aug 16 14:57:09 2006 by 1.4.7