dcl_tcm.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2024 Texas Instruments Incorporated
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef _DCL_TCM_H_
#define _DCL_TCM_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <math.h>
#include "dcl_fdlog.h"
#include "../dcl_common.h"
 
typedef _DCL_VOLATILE struct dcl_tcm {
    DCL_FDLOG moniFrame;    
    DCL_FDLOG leadFrame;    
    DCL_FDLOG captFrame;    
    float32_t trigMax;      
    float32_t trigMin;      
    uint32_t mode;          
    uint32_t lead;          
} DCL_TCM, TCM;
 
#define TCM_DEFAULTS { FDLOG_DEFAULTS, FDLOG_DEFAULTS, FDLOG_DEFAULTS, 0.1, -0.1, 0, 10 }
 
typedef enum dcl_tcm_states 
{
    TCM_INVALID  =  0,    
    TCM_IDLE     =  1,    
    TCM_ARMED    =  2,    
    TCM_CAPTURE  =  3,    
    TCM_COMPLETE =  4,    
} DCL_tcm_states;
 
_DCL_CODE_ACCESS
void DCL_initTCM(DCL_TCM *q, float32_t *addr, uint32_t size, uint32_t lead, float32_t tmin, float32_t tmax)
{
    // assign and clear capture frame, and initialize index to end of lead frame
    DCL_initLog(&(q->captFrame), addr, size);
    DCL_clearLog(&(q->captFrame));
    q->captFrame.dptr = q->captFrame.fptr + lead;
 
    // assign lead & monitor frame pointers
    DCL_initLog(&(q->leadFrame), addr, lead);
    DCL_initLog(&(q->moniFrame), q->captFrame.lptr - lead + 1, lead);
 
    // load remaining TCM vars
    q->lead = lead;
    q->trigMax = tmax;
    q->trigMin = tmin;
    q->mode = TCM_IDLE;
}
 
_DCL_CODE_ACCESS
void DCL_resetTCM(DCL_TCM *q)
{
    DCL_clearLog(&(q->captFrame));
    q->captFrame.dptr = q->captFrame.fptr + q->lead - 1;
    DCL_resetLog(&(q->leadFrame));
    DCL_resetLog(&(q->moniFrame));
    q->mode = TCM_IDLE;
}
 
_DCL_CODE_ACCESS
uint16_t DCL_armTCM(DCL_TCM *q)
{
    q->mode = (q->mode == TCM_IDLE) ? TCM_ARMED : TCM_IDLE;
    return(q->mode);
}
 
_DCL_CODE_ACCESS
uint16_t DCL_runTCM(DCL_TCM *q, float32_t data)
{
    switch(q->mode)
    {
    // TCM not initialized
    case TCM_INVALID:
    // idle: do nothing
    case TCM_IDLE:
    // complete: do nothing - results available in capture buffer
    case TCM_COMPLETE:
    default:
        break;
 
    // armed: ready to begin capturing when either trigger threshold is crossed
    case TCM_ARMED:
        // check for trigger condition
        if ((data > q->trigMax) || (data < q->trigMin))
        {
            // capture first data point & switch to capture mode
            DCL_writeLog(&(q->captFrame), data);
            DCL_writeLog(&(q->leadFrame), DCL_readLog(&(q->moniFrame)));
            q->mode = TCM_CAPTURE;
        }
        else
        {
            // log data into monitor frame
            DCL_writeLog(&(q->moniFrame), data);
        }
        break;
 
    // capture mode: acquiring data
    case TCM_CAPTURE:
        // check for full capture frame
        if (q->captFrame.dptr > q->captFrame.fptr)
        {
            // write data into main frame
            DCL_writeLog(&(q->captFrame), data);
 
            // check for full lead frame
            if (q->leadFrame.dptr > q->leadFrame.fptr)
            {
                // un-wind monitor data into lead frame
                DCL_writeLog(&(q->leadFrame), DCL_readLog(&(q->moniFrame)));
            }
        }
        else
        {
            // TCM complete, capture frame spans full buffer
            q->captFrame.fptr = q->leadFrame.fptr;
            q->captFrame.dptr = q->captFrame.fptr;
            q->mode = TCM_COMPLETE;
        }
        break;
    }
 
    return(q->mode);
}
 
_DCL_CODE_ACCESS
float32_t DCL_runITAE(DCL_FDLOG *elog, float32_t prd)
{
    float32_t tim = 0.0f;
    float32_t rlt = 0.0f;
    uint32_t size = DCL_getLogSize(elog);
 
    // set index pointer to buffer start
    DCL_resetLog(elog);
 
    // accumulate ITAE data
    while (size--)
    {
        rlt += fabs(*(elog->dptr++)) * tim;
        tim += prd;
    }
    DCL_resetLog(elog);
 
    return(rlt);
}
 
_DCL_CODE_ACCESS
float32_t DCL_runIAE(DCL_FDLOG *elog)
{
    float32_t rlt = 0.0f;
    uint32_t size = DCL_getLogSize(elog);
 
    // set index pointer to buffer start
    DCL_resetLog(elog);
 
    // accumulate IAE data
    while (size--)
    {
        rlt += fabs(*(elog->dptr++));
    }
    DCL_resetLog(elog);
 
    return(rlt);
}
 
_DCL_CODE_ACCESS
float32_t DCL_runIES(DCL_FDLOG *elog)
{
    float32_t err;
    float32_t rlt = 0.0f;
    uint32_t size = DCL_getLogSize(elog);
 
    // set index pointers to buffer start
    DCL_resetLog(elog);
 
    // accumulate IES data
    while (size--)
    {
        err = *(elog->dptr++);
        rlt += (err * err);
    }
 
    // restore index pointer
    DCL_resetLog(elog);
 
    return(rlt);
}
 
#ifdef __cplusplus
}
#endif // extern "C"
 
#endif // _DCL_TCM_H_