epicsdouble.cpp

Go to the documentation of this file.

#include "epicsdouble.h"
#include <QMutexLocker>
#include <math.h>
#include <stdio.h>

EpicsDouble::EpicsDouble(QString pvName, QObject *parent, int dbg)
  : EpicsObject(pvName, parent, dbg)
{
  if (debug()) {
    printf("EpicsDouble::EpicsDouble(%s)\n", qPrintable(pvName));
  }

  m_Value.value = NAN;
}

EpicsDouble::~EpicsDouble()
{
}

void EpicsDouble::connected()
{
  if (!m_HasEventHandler) {
    SEVCHK(ca_create_subscription(DBR_GR_DOUBLE, 0, m_ChannelID, DBE_VALUE|DBE_ALARM, 
                                  get_event_handler(), this, &m_EventID), NULL);

    m_HasEventHandler = 1;

    if (debug()) {
      printf("Channel %s connected\n", qPrintable(pvName()));
    }
  }
}

void EpicsDouble::event_handler(struct event_handler_args args)
{
  union db_access_val *pb = (union db_access_val *) args.dbr;

  dbr_gr_double res;
  memset(&res, 0xff, sizeof(dbr_gr_double));

  switch (args.type) {
  case DBR_GR_DOUBLE:
    res=pb->gdblval;
    break;
  default:
    printf("data type %ld not supported\n", args.type);
  }

  EpicsDouble *r = ((EpicsDouble*) args.usr);

  if (r && r->debug()) {
    printf("%s Epics Double Event Handler called %ld = %g\n", ca_name(args.chid), args.type, res.value);
  }

  ((EpicsDouble*) args.usr) -> changeValue(res);
}

caEventCallBackFunc *EpicsDouble::get_event_handler()
{
  return &EpicsDouble::event_handler;
}

void EpicsDouble::changeValue(dbr_gr_double newval)
{
  if (debug()) {
    printf("ca_put(%d,%p,%g)\n", DBR_DOUBLE, channelID(), newval);
  }

//  ca_put(DBR_DOUBLE, channelID(), &newval);

  QMutexLocker lock(&m_Mutex);

  int valchanged=0;
  int grpchanged=0;

  if (m_Value.value != newval.value) {
    valchanged=1;
  }

  if ((m_Value.status != newval.status) ||
      (m_Value.severity != newval.severity) ||
      (m_Value.precision != newval.precision) ||
      (m_Value.upper_disp_limit != newval.upper_disp_limit) ||
      (m_Value.lower_disp_limit != newval.lower_disp_limit) ||
      (m_Value.upper_warning_limit != newval.upper_warning_limit) ||
      (m_Value.lower_warning_limit != newval.lower_warning_limit) ||
      (m_Value.upper_alarm_limit != newval.upper_alarm_limit) ||
      (m_Value.lower_alarm_limit != newval.lower_alarm_limit) ||
      (strcmp(m_Value.units,newval.units) != 0)) {
    grpchanged = 1;
  }

  m_Value = newval;

  if (valchanged) {
    emit valueChanged(m_Value.value);
  }

  if (grpchanged) {
    emit valueGraphicChanged(m_Value);
  }
}

void EpicsDouble::caput(double val)
{
  ca_put(DBR_DOUBLE, channelID(), &val);
  ca_pend_io(0.5);
}

double EpicsDouble::value()
{
  QMutexLocker lock(&m_Mutex);

  return m_Value.value;
}