471 lines
12 KiB
C
471 lines
12 KiB
C
/*************************************************************************\
|
||
* Copyright (c) 2008 UChicago Argonne LLC, as Operator of Argonne
|
||
* National Laboratory.
|
||
* Copyright (c) 2002 The Regents of the University of California, as
|
||
* Operator of Los Alamos National Laboratory.
|
||
* EPICS BASE is distributed subject to a Software License Agreement found
|
||
* in file LICENSE that is included with this distribution.
|
||
\*************************************************************************/
|
||
|
||
/* $Revision-Id$ */
|
||
/*
|
||
* Original Author: Bob Dalesio
|
||
* Date: 7-14-89
|
||
*/
|
||
|
||
#include <stddef.h>
|
||
#include <stdlib.h>
|
||
#include <stdarg.h>
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
#include <math.h>
|
||
|
||
#include "dbDefs.h"
|
||
#include "epicsPrint.h"
|
||
#include "alarm.h"
|
||
#include "dbStaticLib.h"
|
||
#include "dbAccess.h"
|
||
#include "dbEvent.h"
|
||
#include "dbFldTypes.h"
|
||
#include "errMdef.h"
|
||
#include "special.h"
|
||
#include "recSup.h"
|
||
#include "recGbl.h"
|
||
|
||
#define GEN_SIZE_OFFSET
|
||
#include "compressRecord.h"
|
||
#undef GEN_SIZE_OFFSET
|
||
#include "epicsExport.h"
|
||
|
||
#define indexof(field) compressRecord##field
|
||
|
||
/* Create RSET - Record Support Entry Table*/
|
||
#define report NULL
|
||
#define initialize NULL
|
||
static long init_record(compressRecord *, int);
|
||
static long process(compressRecord *);
|
||
static long special(DBADDR *, int);
|
||
#define get_value NULL
|
||
static long cvt_dbaddr(DBADDR *);
|
||
static long get_array_info(DBADDR *, long *, long *);
|
||
static long put_array_info(DBADDR *, long);
|
||
static long get_units(DBADDR *, char *);
|
||
static long get_precision(DBADDR *, long *);
|
||
#define get_enum_str NULL
|
||
#define get_enum_strs NULL
|
||
#define put_enum_str NULL
|
||
static long get_graphic_double(DBADDR *, struct dbr_grDouble *);
|
||
static long get_control_double(DBADDR *, struct dbr_ctrlDouble *);
|
||
#define get_alarm_double NULL
|
||
|
||
rset compressRSET = {
|
||
RSETNUMBER,
|
||
report,
|
||
initialize,
|
||
init_record,
|
||
process,
|
||
special,
|
||
get_value,
|
||
cvt_dbaddr,
|
||
get_array_info,
|
||
put_array_info,
|
||
get_units,
|
||
get_precision,
|
||
get_enum_str,
|
||
get_enum_strs,
|
||
put_enum_str,
|
||
get_graphic_double,
|
||
get_control_double,
|
||
get_alarm_double
|
||
};
|
||
epicsExportAddress(rset,compressRSET);
|
||
|
||
|
||
static void reset(compressRecord *prec)
|
||
{
|
||
prec->nuse = 0;
|
||
prec->off = 0;
|
||
prec->inx = 0;
|
||
prec->cvb = 0.0;
|
||
prec->res = 0;
|
||
/* allocate memory for the summing buffer for conversions requiring it */
|
||
if (prec->alg == compressALG_Average && prec->sptr == 0){
|
||
prec->sptr = calloc(prec->nsam, sizeof(double));
|
||
}
|
||
}
|
||
|
||
static void monitor(compressRecord *prec)
|
||
{
|
||
unsigned short alarm_mask = recGblResetAlarms(prec);
|
||
unsigned short monitor_mask = alarm_mask | DBE_LOG | DBE_VALUE;
|
||
|
||
if (alarm_mask || prec->nuse != prec->ouse) {
|
||
db_post_events(prec, &prec->nuse, monitor_mask);
|
||
prec->ouse = prec->nuse;
|
||
}
|
||
db_post_events(prec, prec->bptr, monitor_mask);
|
||
}
|
||
|
||
static void put_value(compressRecord *prec, double *psource, int n)
|
||
{
|
||
epicsInt32 offset = prec->off;
|
||
epicsInt32 nuse = prec->nuse;
|
||
epicsInt32 nsam = prec->nsam;
|
||
double *pdest = prec->bptr + offset;
|
||
int i;
|
||
|
||
for (i = 0; i < n; i++) {
|
||
*pdest = *psource++;
|
||
if (++offset >= nsam) {
|
||
pdest = prec->bptr;
|
||
offset = 0;
|
||
}
|
||
else
|
||
pdest++;
|
||
}
|
||
nuse += n;
|
||
if (nuse > nsam)
|
||
nuse = nsam;
|
||
prec->off = offset;
|
||
prec->nuse = nuse;
|
||
return;
|
||
}
|
||
|
||
/* qsort comparison function (for median calculation) */
|
||
static int compare(const void *arg1, const void *arg2)
|
||
{
|
||
double a = *(double *)arg1;
|
||
double b = *(double *)arg2;
|
||
|
||
if ( a < b ) return -1;
|
||
else if ( a == b ) return 0;
|
||
else return 1;
|
||
}
|
||
|
||
static int compress_array(compressRecord *prec,
|
||
double *psource, int no_elements)
|
||
{
|
||
epicsInt32 i,j;
|
||
epicsInt32 nnew;
|
||
epicsInt32 nsam=prec->nsam;
|
||
double value;
|
||
epicsInt32 n;
|
||
|
||
/* skip out of limit data */
|
||
if (prec->ilil < prec->ihil){
|
||
while (((*psource < prec->ilil) || (*psource > prec->ihil))
|
||
&& (no_elements > 0)){
|
||
no_elements--;
|
||
psource++;
|
||
}
|
||
}
|
||
if(prec->n <= 0) prec->n = 1;
|
||
n = prec->n;
|
||
if(no_elements<n) return(1); /*dont do anything*/
|
||
|
||
/* determine number of samples to take */
|
||
if (no_elements < (nsam * n)) nnew = (no_elements / n);
|
||
else nnew = nsam;
|
||
|
||
/* compress according to specified algorithm */
|
||
switch (prec->alg){
|
||
case (compressALG_N_to_1_Low_Value):
|
||
/* compress N to 1 keeping the lowest value */
|
||
for (i = 0; i < nnew; i++){
|
||
value = *psource++;
|
||
for (j = 1; j < n; j++, psource++){
|
||
if (value > *psource) value = *psource;
|
||
}
|
||
put_value(prec,&value,1);
|
||
}
|
||
break;
|
||
case (compressALG_N_to_1_High_Value):
|
||
/* compress N to 1 keeping the highest value */
|
||
for (i = 0; i < nnew; i++){
|
||
value = *psource++;
|
||
for (j = 1; j < n; j++, psource++){
|
||
if (value < *psource) value = *psource;
|
||
}
|
||
put_value(prec,&value,1);
|
||
}
|
||
break;
|
||
case (compressALG_N_to_1_Average):
|
||
/* compress N to 1 keeping the average value */
|
||
for (i = 0; i < nnew; i++){
|
||
value = 0;
|
||
for (j = 0; j < n; j++, psource++)
|
||
value += *psource;
|
||
value /= n;
|
||
put_value(prec,&value,1);
|
||
}
|
||
break;
|
||
case (compressALG_N_to_1_Median):
|
||
/* compress N to 1 keeping the median value */
|
||
/* note: sorts source array (OK; it's a work pointer) */
|
||
for (i = 0; i < nnew; i++, psource+=nnew){
|
||
qsort(psource,n,sizeof(double),compare);
|
||
value=psource[n/2];
|
||
put_value(prec,&value,1);
|
||
}
|
||
break;
|
||
}
|
||
return(0);
|
||
}
|
||
|
||
static int array_average(compressRecord *prec,
|
||
double *psource,epicsInt32 no_elements)
|
||
{
|
||
epicsInt32 i;
|
||
epicsInt32 nnow;
|
||
epicsInt32 nsam=prec->nsam;
|
||
double *psum;
|
||
double multiplier;
|
||
epicsInt32 inx=prec->inx;
|
||
epicsInt32 nuse,n;
|
||
|
||
nuse = nsam;
|
||
if(nuse>no_elements) nuse = no_elements;
|
||
nnow=nuse;
|
||
if(nnow>no_elements) nnow=no_elements;
|
||
psum = (double *)prec->sptr;
|
||
|
||
/* add in the new waveform */
|
||
if (inx == 0){
|
||
for (i = 0; i < nnow; i++)
|
||
*psum++ = *psource++;
|
||
for(i=nnow; i<nuse; i++) *psum++ = 0;
|
||
}else{
|
||
for (i = 0; i < nnow; i++)
|
||
*psum++ += *psource++;
|
||
}
|
||
|
||
/* do we need to calculate the result */
|
||
inx++;
|
||
if(prec->n<=0)prec->n=1;
|
||
n = prec->n;
|
||
if (inx<n) {
|
||
prec->inx = inx;
|
||
return(1);
|
||
}
|
||
if(n>1) {
|
||
psum = (double *)prec->sptr;
|
||
multiplier = 1.0/((double)n);
|
||
for (i = 0; i < nuse; i++, psum++)
|
||
*psum = *psum * multiplier;
|
||
}
|
||
put_value(prec,prec->sptr,nuse);
|
||
prec->inx = 0;
|
||
return(0);
|
||
}
|
||
|
||
static int compress_scalar(struct compressRecord *prec,double *psource)
|
||
{
|
||
double value = *psource;
|
||
double *pdest=&prec->cvb;
|
||
epicsInt32 inx = prec->inx;
|
||
|
||
/* compress according to specified algorithm */
|
||
switch (prec->alg){
|
||
case (compressALG_N_to_1_Low_Value):
|
||
if ((value < *pdest) || (inx == 0))
|
||
*pdest = value;
|
||
break;
|
||
case (compressALG_N_to_1_High_Value):
|
||
if ((value > *pdest) || (inx == 0))
|
||
*pdest = value;
|
||
break;
|
||
/* for scalars, Median not implemented => use average */
|
||
case (compressALG_N_to_1_Average):
|
||
case (compressALG_N_to_1_Median):
|
||
if (inx == 0)
|
||
*pdest = value;
|
||
else {
|
||
*pdest += value;
|
||
if(inx+1>=(prec->n)) *pdest = *pdest/(inx+1);
|
||
}
|
||
break;
|
||
}
|
||
inx++;
|
||
if(inx>=prec->n) {
|
||
put_value(prec,pdest,1);
|
||
prec->inx = 0;
|
||
return(0);
|
||
} else {
|
||
prec->inx = inx;
|
||
return(1);
|
||
}
|
||
}
|
||
|
||
/*Beginning of record support routines*/
|
||
static long init_record(compressRecord *prec, int pass)
|
||
{
|
||
if (pass == 0) {
|
||
if (prec->nsam < 1)
|
||
prec->nsam = 1;
|
||
prec->bptr = calloc(prec->nsam, sizeof(double));
|
||
reset(prec);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static long process(compressRecord *prec)
|
||
{
|
||
long status = 0;
|
||
long nelements = 0;
|
||
int alg = prec->alg;
|
||
|
||
prec->pact = TRUE;
|
||
if (!dbIsLinkConnected(&prec->inp) ||
|
||
dbGetNelements(&prec->inp, &nelements) ||
|
||
nelements <= 0) {
|
||
recGblSetSevr(prec, LINK_ALARM, INVALID_ALARM);
|
||
}
|
||
else {
|
||
if (!prec->wptr || nelements != prec->inpn) {
|
||
if (prec->wptr) {
|
||
free(prec->wptr);
|
||
reset(prec);
|
||
}
|
||
prec->wptr = dbCalloc(nelements, sizeof(double));
|
||
prec->inpn = nelements;
|
||
}
|
||
status = dbGetLink(&prec->inp, DBF_DOUBLE, prec->wptr, 0, &nelements);
|
||
if (status || nelements <= 0) {
|
||
recGblSetSevr(prec, LINK_ALARM, INVALID_ALARM);
|
||
status = 0;
|
||
}
|
||
else if (alg == compressALG_Average) {
|
||
status = array_average(prec, prec->wptr, nelements);
|
||
}
|
||
else if (alg == compressALG_Circular_Buffer) {
|
||
put_value(prec, prec->wptr, nelements);
|
||
status = 0;
|
||
}
|
||
else if (nelements > 1) {
|
||
status = compress_array(prec, prec->wptr, nelements);
|
||
}
|
||
else if (nelements == 1){
|
||
status = compress_scalar(prec, prec->wptr);
|
||
}
|
||
else
|
||
status = 1;
|
||
}
|
||
/* check event list */
|
||
if (status != 1) {
|
||
prec->udf = FALSE;
|
||
recGblGetTimeStamp(prec);
|
||
monitor(prec);
|
||
/* process the forward scan link record */
|
||
recGblFwdLink(prec);
|
||
}
|
||
prec->pact = FALSE;
|
||
return 0;
|
||
}
|
||
|
||
static long special(DBADDR *paddr, int after)
|
||
{
|
||
compressRecord *prec = (compressRecord *) paddr->precord;
|
||
int special_type = paddr->special;
|
||
|
||
if (!after)
|
||
return 0;
|
||
|
||
if (special_type == SPC_RESET) {
|
||
reset(prec);
|
||
return 0;
|
||
}
|
||
|
||
recGblDbaddrError(S_db_badChoice, paddr, "compress: special");
|
||
return S_db_badChoice;
|
||
}
|
||
|
||
static long cvt_dbaddr(DBADDR *paddr)
|
||
{
|
||
compressRecord *prec = (compressRecord *) paddr->precord;
|
||
|
||
paddr->pfield = prec->bptr;
|
||
paddr->no_elements = prec->nsam;
|
||
paddr->field_type = DBF_DOUBLE;
|
||
paddr->field_size = sizeof(double);
|
||
paddr->dbr_field_type = DBF_DOUBLE;
|
||
return 0;
|
||
}
|
||
|
||
static long get_array_info(DBADDR *paddr, long *no_elements, long *offset)
|
||
{
|
||
compressRecord *prec = (compressRecord *) paddr->precord;
|
||
|
||
*no_elements = prec->nuse;
|
||
if (prec->nuse == prec->nsam)
|
||
*offset = prec->off;
|
||
else
|
||
*offset = 0;
|
||
return 0;
|
||
}
|
||
|
||
static long put_array_info(DBADDR *paddr, long nNew)
|
||
{
|
||
compressRecord *prec = (compressRecord *) paddr->precord;
|
||
|
||
prec->off = (prec->off + nNew) % prec->nsam;
|
||
prec->nuse += nNew;
|
||
if (prec->nuse > prec->nsam)
|
||
prec->nuse = prec->nsam;
|
||
return 0;
|
||
}
|
||
|
||
static long get_units(DBADDR *paddr, char *units)
|
||
{
|
||
compressRecord *prec = (compressRecord *) paddr->precord;
|
||
|
||
if (paddr->pfldDes->field_type == DBF_DOUBLE ||
|
||
dbGetFieldIndex(paddr) == indexof(VAL)) {
|
||
strncpy(units, prec->egu, DB_UNITS_SIZE);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static long get_precision(DBADDR *paddr, long *precision)
|
||
{
|
||
compressRecord *prec = (compressRecord *) paddr->precord;
|
||
|
||
*precision = prec->prec;
|
||
if (dbGetFieldIndex(paddr) != indexof(VAL))
|
||
recGblGetPrec(paddr,precision);
|
||
return 0;
|
||
}
|
||
|
||
static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
|
||
{
|
||
compressRecord *prec = (compressRecord *) paddr->precord;
|
||
|
||
switch (dbGetFieldIndex(paddr)) {
|
||
case indexof(VAL):
|
||
case indexof(IHIL):
|
||
case indexof(ILIL):
|
||
pgd->upper_disp_limit = prec->hopr;
|
||
pgd->lower_disp_limit = prec->lopr;
|
||
break;
|
||
default:
|
||
recGblGetGraphicDouble(paddr,pgd);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd)
|
||
{
|
||
compressRecord *prec = (compressRecord *) paddr->precord;
|
||
|
||
switch (dbGetFieldIndex(paddr)) {
|
||
case indexof(VAL):
|
||
case indexof(IHIL):
|
||
case indexof(ILIL):
|
||
pcd->upper_ctrl_limit = prec->hopr;
|
||
pcd->lower_ctrl_limit = prec->lopr;
|
||
break;
|
||
default:
|
||
recGblGetControlDouble(paddr, pcd);
|
||
}
|
||
return 0;
|
||
}
|