仿真数字正弦波发生器程序

已于 2023-10-26 11:36:58 修改
阅读量303 收藏 3
点赞数 1
分类专栏： EPICS教程 Linux C 文章标签： EPICS C语言 linux
于 2023-10-26 11:35:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuyuyuliang00/article/details/134051681
版权

1）构建这个IOC程序的程序框架：

orangepi@orangepi5:/usr/local/EPICS/program/simScope$ ls
bin  configure  db  dbd  iocBoot  lib  Makefile  simScopeApp

2）修改configure下RELEASE文件，添加所需的支持模块，此IOC程序需要asyn模块支持，因此添加以下两行：

...

# Variables and paths to dependent modules:
#MODULES = /path/to/modules
#MYMODULE = $(MODULES)/my-module
SUPPORT=/usr/local/EPICS/synApps/support
ASYN=$(SUPPORT)/asyn

...

3) 进入simScopeApp/src/目录下，编写以下以下三个文件：

simScope.cpp  simScope.h  simScopeSupport.dbd

a) simScope.h：

#include <asynPortDriver.h>

#define NUM_VERT_SELECTIONS     4

/* drvInfo string*/
#define P_RunString                     "SCOPE_RUN"                     /* asynInt32 r/w start/stop backgroud thread */
#define P_MaxPointsString               "SCOPE_MAX_POINTS"              /* asynInt32 r/o max number of data points   */
#define P_TimePerDivString              "SCOPE_TIME_PER_DIV"            /* asynFloat64 r/w Time Per Div              */
#define P_TimePerDivSelectString        "SCOPE_TIME_PER_DIV_SELECT"     /* asynInt32 r/w   Time Per Div Choices      */
#define P_VertGainString                "SCOPE_VERT_GAIN"               /* asynFloat64 r/w Vert Gain                 */
#define P_VertGainSelectString          "SCOPE_VERT_GAIN_SELECT"        /* asynInt32 r/w Vert Gain Choices           */
#define P_VoltsPerDivString             "SCOPE_VOLTS_PER_DIV"           /* asynFloat64 r/w Volts Per Div             */
#define P_VoltsPerDivSelectString       "SCOPE_VOLTS_PER_DIV_SELECT"    /* asynInt32 r/w Volts Per Div Choices       */
#define P_VoltOffsetString              "SCOPE_VOLT_OFFSET"             /* asynFloat64 r/w Volt Offset               */
#define P_TriggerDelayString            "SCOPE_TRIGGER_DELAY"           /* asynFloat64 r/w Trigger Delay             */
#define P_NoiseAmplitudeString          "SCOPE_NOISE_AMPLITUDE"         /* asynFloat64 r/w Noise Amplitude           */
#define P_UpdateTimeString              "SCOPE_UPDATE_TIME"             /* asynFloat64 r/w Update Time               */
#define P_WaveformString                "SCOPE_WAVEFORM"                /* asynFloat64Array r/o waveform data array  */
#define P_TimeBaseString                "SCOPE_TIME_BASE"               /* asynFloat64Array r/o time base array      */
#define P_MinValueString                "SCOPE_MIN_VALUE"               /* asynFloat64 r/o min data */
#define P_MaxValueString                "SCOPE_MAX_VALUE"               /* asynFloat64 r/o max data */
#define P_MeanValueString               "SCOPE_MEAN_VALUE"              /* asynFloat64 r/o mean data */

class simScope : public asynPortDriver
{
public:
        simScope(const char * portName, int maxArraySize);
        /* There method overwritten from asynPortDriver */
        virtual asynStatus writeInt32(asynUser *pasynUser, epicsInt32 value);
        virtual asynStatus writeFloat64(asynUser *pasynUser, epicsFloat64 value);
        virtual asynStatus readFloat64Array(asynUser *pasynUser, epicsFloat64 *value, size_t nElements, size_t *nIn);
        virtual asynStatus readEnum(asynUser *pasynUser, char *strings[], int values[], int severties[], size_t nElements, size_t *nIn);

        void simTask(void);

protected:
        /* index for parameter in the parameter library */
        int P_Run;
        int P_MaxPoints;
        int P_TimePerDiv;
        int P_TimePerDivSelect;
        int P_VertGain;
        int P_VertGainSelect;
        int P_VoltsPerDiv;
        int P_VoltsPerDivSelect;
        int P_VoltOffset;
        int P_TriggerDelay;
        int P_NoiseAmplitude;
        int P_UpdateTime;
        int P_Waveform;
        int P_TimeBase;
        int P_MinValue;
        int P_MaxValue;
        int P_MeanValue;

private:
        /* event to send sigal to background thread */
        epicsEventId eventId_;
        /* waveform data array     */
        epicsFloat64 *pData_;
        /* waveform timebase array */
        epicsFloat64 *pTimeBase_;
        /* string array for Volts Per Div Choices*/
        char *voltsPerDivStrings_[NUM_VERT_SELECTIONS];
        /* value array for Volts Per Div Choices */
        int voltsPerDivValues_[NUM_VERT_SELECTIONS];
        /* severities array for Volts Per Div Choices */
        int voltsPerDivSeverities_[NUM_VERT_SELECTIONS];

        /* set Vert Gain */
        void setVertGain();
        /* set Volts Per Div according to voltsPerDivSelect */
        void setVoltsPerDiv();
        /* set Time Per Div according to TimePerDivSelect   */
        void setTimePerDiv();
};

b) simScope.cpp：

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <math.h>

#include <epicsTypes.h>
#include <epicsTime.h>
#include <epicsThread.h>
#include <epicsString.h>
#include <epicsTimer.h>
#include <epicsMutex.h>
#include <epicsEvent.h>
#include <iocsh.h>

#include  "simScope.h"
#include <epicsExport.h>

#define FREQUENCY               1000    /* volt signal frequency */
#define AMPLITUDE               1.0     /* volt signal amplitude */
#define NUM_DIVISIONS           10      /* horizontal and vertical axis' divisions */
#define MIN_UPDATE_TIME         0.05    /* the min update time for the waveform data */

#define MAX_ENUM_STRING_SIZE    20
/* This driver's Name */
static const char * driverName = "simScope";

static int allVoltsPerDivSelections[NUM_VERT_SELECTIONS] = {1,2,5,10};
/* For C Call */
void simTask(void * pdrvPvt);

simScope::simScope(const char * portName, int maxPoints)
        :asynPortDriver(portName,
                        1,
                        asynInt32Mask | asynFloat64Mask | asynFloat64ArrayMask | asynEnumMask | asynDrvUserMask,
                        asynInt32Mask | asynFloat64Mask | asynFloat64ArrayMask | asynEnumMask,
                        0, /* asynFlags  */
                        1, /* autoconnect*/
                        0, /* Default priority   */
                        0) /* Default stack size */
{
        asynStatus status;
        int i;
        const char *functionName = "simScope";

        /* make sure the number of points at least 100 points */
        if (maxPoints < 100){
                maxPoints = 100;
        }
        printf("Come to Contruct the simScope instance\n");

        /* allocate space for waveform data */
        pData_ = (epicsFloat64 *)calloc( maxPoints, sizeof(epicsFloat64));
        /* allocate space for timebase */
        pTimeBase_ = (epicsFloat64 *)calloc(maxPoints, sizeof(epicsFloat64));
        /* set the interval between pTimeBase_ elements */
        for (i = 0; i < maxPoints; i++){ // the number of divisions is NUM_DIVISIONS
                pTimeBase_[i] = (epicsFloat64)i/ (maxPoints - 1)  * NUM_DIVISIONS ;
        }

        // create the event for sending signal to the background thread
        eventId_ = epicsEventCreate(epicsEventEmpty);

        printf("Come before create parameters\n");
        /* create the parameters for communicating with epics Records */
        createParam(P_RunString,                asynParamInt32,         &P_Run);
        createParam(P_MaxPointsString,          asynParamInt32,         &P_MaxPoints);
        createParam(P_TimePerDivString,         asynParamFloat64,       &P_TimePerDiv);
        createParam(P_TimePerDivSelectString,   asynParamInt32,         &P_TimePerDivSelect);
        createParam(P_VertGainString,           asynParamFloat64,       &P_VertGain);
        createParam(P_VertGainSelectString,     asynParamInt32,         &P_VertGainSelect);
        createParam(P_VoltsPerDivString,        asynParamFloat64,       &P_VoltsPerDiv);
        createParam(P_VoltsPerDivSelectString,  asynParamInt32,         &P_VoltsPerDivSelect);
        createParam(P_VoltOffsetString,         asynParamFloat64,       &P_VoltOffset);
        createParam(P_TriggerDelayString,       asynParamFloat64,       &P_TriggerDelay);
        createParam(P_NoiseAmplitudeString,     asynParamFloat64,       &P_NoiseAmplitude);
        createParam(P_UpdateTimeString,         asynParamFloat64,       &P_UpdateTime);
        createParam(P_WaveformString,           asynParamFloat64Array,  &P_Waveform);
        createParam(P_TimeBaseString,           asynParamFloat64Array,  &P_TimeBase);
        createParam(P_MinValueString,           asynParamFloat64,       &P_MinValue);
        createParam(P_MaxValueString,           asynParamFloat64,       &P_MaxValue);
        createParam(P_MeanValueString,          asynParamFloat64,       &P_MeanValue);

        /* alloc space for vert per divistion strings */
        for (i = 0; i < NUM_VERT_SELECTIONS; i++){
                voltsPerDivValues_[i] = 0;
                voltsPerDivSeverities_[i] = 0;
                voltsPerDivStrings_[i] = (char *)calloc(MAX_ENUM_STRING_SIZE,   sizeof(char));
        }

        setIntegerParam(P_MaxPoints,            maxPoints);
        setIntegerParam(P_Run,                  0);
        setIntegerParam(P_VertGainSelect,       10);
        /* set the arrays voltsPerDivValues_,  voltsPerDivString_ according to P_VertGainSelect parameter*/
        setVertGain();
        setDoubleParam(P_VoltsPerDiv,           1.0);
        setDoubleParam(P_VoltOffset,            0.0);
        setDoubleParam(P_TriggerDelay,          0.0);
        setDoubleParam(P_NoiseAmplitude,        0.1);
        setDoubleParam(P_UpdateTime,            1);
        setDoubleParam(P_TimePerDiv,            0.001);
        setDoubleParam(P_MinValue,              0.0);
        setDoubleParam(P_MaxValue,              0.0);
        setDoubleParam(P_MeanValue,             0.0);

        printf("Come after Create Parameters and set defaults for these parameters\n");
        printf("Come before create background thread\n");
        status = (asynStatus)(epicsThreadCreate("simScope",
                        epicsThreadPriorityMedium,
                        epicsThreadGetStackSize(epicsThreadStackMedium),
                        (EPICSTHREADFUNC)::simTask,
                        (void *)this) == NULL);
        printf("Come after create background thread\n");

        if (status){
                printf("%s:%s: epicsThreadCreate failure\n", driverName, functionName);
                return;
        }

        printf("Come to the end of contructing simScope Intances: portName: %s, maxPoints:%d\n", portName, maxPoints);
}

void simScope::setVertGain()
{
        epicsInt32 igain, i;
        double gain;

        // P_VertGainSelect for mbbo  to Vert Gain
        getIntegerParam(P_VertGainSelect,       &igain);
        gain =(epicsFloat64) igain;
        setDoubleParam(P_VertGain, gain);

        printf("VertGainSelect: %d, VertGain: %lf\n", igain, gain);

        for (i = 0; i < NUM_VERT_SELECTIONS; i++){
                epicsSnprintf(voltsPerDivStrings_[i], MAX_ENUM_STRING_SIZE, "%.2f",allVoltsPerDivSelections[i] / gain);
                voltsPerDivValues_[i] = (int)(allVoltsPerDivSelections[i] / gain * 1000 + 0.5);
                printf("%d: V/Div=%d, %s\n", i+1, voltsPerDivValues_[i], voltsPerDivStrings_[i]);
        }

        //doCallbacksEnum(voltsPerDivStrings_, voltsPerDivValues_, voltsPerDivSeverities_, NUM_VERT_SELECTIONS, P_VoltsPerDivSelect, 0);
        doCallbacksEnum(voltsPerDivStrings_, voltsPerDivValues_, voltsPerDivSeverities_, NUM_VERT_SELECTIONS, P_VoltsPerDivSelect, 0);
}




void simScope::setVoltsPerDiv()
{
        epicsInt32 mVPerDiv;

        getIntegerParam(P_VoltsPerDivSelect,    &mVPerDiv);
        setDoubleParam(P_VoltsPerDiv,           mVPerDiv / 1000.0);
        printf("VoltsPerDivSelect: %d, VoltsPerDiv: %lf\n", mVPerDiv, mVPerDiv/1000.0);
}


/*
 * P_TimePerDivSelect parameter is in micro second
 * P_TimePerDiv parameter is in second
 * */
void simScope::setTimePerDiv()
{
        epicsInt32 microSecPerDiv;

        getIntegerParam(P_TimePerDivSelect,     &microSecPerDiv);
        setDoubleParam(P_TimePerDiv,            microSecPerDiv / 1000000.0);
}

asynStatus simScope::writeInt32(asynUser * pasynUser, epicsInt32 value)
{
        int function = pasynUser->reason;
        asynStatus status = asynSuccess;
        const char * paramName;
        const char * functionName = "writeInt32";

        /* set the value for the parameter */
        status = (asynStatus) setIntegerParam(function, value);
        /*  get name of the parameter */
        getParamName(function, &paramName);

        if (function == P_Run){
                if (value) epicsEventSignal(eventId_);
        }
        else if (function == P_VertGainSelect){
                setVertGain();
        }
        else if (function == P_VoltsPerDivSelect){
                setVoltsPerDiv();
        }
        else if (function == P_TimePerDivSelect){
                setTimePerDiv(); // set P_TimePerDiv parameter according to P_TimePerDivSelect parameter
        }
        else{
        }

        status = (asynStatus) callParamCallbacks();

        if (status){
                epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, functino=%d,parameter name=%s, value=%d", driverName, functionName, status, function, paramName, value);
        }
        else{
                asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d,parameter name=%s, value=%d", driverName, functionName, function, paramName, value);
        }

        return status;
}

asynStatus simScope::writeFloat64(asynUser * pasynUser, epicsFloat64 value)
{
        int function = pasynUser->reason;
        asynStatus status;
        epicsInt32 run;
        const char * paramName;
        const char * functionName = "writeFloat64";

        status = (asynStatus)setDoubleParam(function, value);

        getParamName(function, &paramName);

        if (function == P_UpdateTime){
                if (value < MIN_UPDATE_TIME){
                        asynPrint(pasynUser, ASYN_TRACE_WARNING, "%s:%s warning, update time too small, changed from %f to %f\n", driverName, functionName, value, MIN_UPDATE_TIME);
                        value = MIN_UPDATE_TIME;
                        setDoubleParam(P_UpdateTime, value);
                }

                getIntegerParam(P_Run, &run);
        }
        else{
        }

        status = (asynStatus) callParamCallbacks();
        if (status){
                epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, parameter name=%s, value=%f",
                                driverName, functionName, status, function, paramName, value);
        }
        else{
                asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d, parameter name = %s, value = %f\n", driverName, functionName, function, paramName, value);
        }

        return status;
}

asynStatus simScope::readFloat64Array(asynUser *pasynUser, epicsFloat64 *value , size_t nElements, size_t *nIn)
{
        int function = pasynUser->reason;
        size_t nCopy;
        epicsInt32 maxPoints;
        asynStatus status = asynSuccess;
        epicsTimeStamp timeStamp;
        const char *functionName = "readFloat64Array";
        const char * paramName;

        getTimeStamp(&timeStamp);
        pasynUser->timestamp = timeStamp;
        getIntegerParam(P_MaxPoints, &maxPoints);
        nCopy = maxPoints;
        getParamName(function, &paramName);

        if (nElements < nCopy) nCopy = nElements;
        if (function == P_Waveform){
                memcpy(value, pData_, nCopy * sizeof(epicsFloat64));
                * nIn = nCopy;
        }
        else if (function == P_TimeBase){
                memcpy(value, pTimeBase_, nCopy * sizeof(epicsFloat64));
                * nIn = nCopy;
        }

        if(status){
                epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, parameter name=%s", driverName,  functionName, status, function, paramName);
        }
        else{
                asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d, parameter name=%s\n", driverName, functionName, function, paramName);
        }

        return status;
}

asynStatus simScope::readEnum(asynUser * pasynUser, char *strings[], int values[], int severities[], size_t nElements, size_t *nIn)
{
        int function = pasynUser->reason;
        size_t i;

        if (function == P_VoltsPerDivSelect){
                for (i = 0; ((i < NUM_VERT_SELECTIONS) && (i < nElements)); i++){
                        if (strings[i]) free(strings[i]);
                        strings[i] = epicsStrDup(voltsPerDivStrings_[i]);
                        values[i] = voltsPerDivValues_[i];
                        severities[i] = 0;
                }
        }
        else{
                *nIn = 0;
                return asynError;
        }

        *nIn = i;

        return asynSuccess;
}

void simScope::simTask()
{
        double timePerDiv, voltsPerDiv, voltOffset, triggerDelay, noiseAmplitude;
        double updateTime, minValue, maxValue, meanValue;
        double time, timeStep;
        double noise, yScale;
        epicsInt32 run, i, maxPoints;
        double pi = 3.1415926;

        printf("Enter in the simTask() functinon:\n");
        lock();

        printf("Enter in loop forever:\n");
        while (1){
                getDoubleParam(P_UpdateTime, &updateTime);
                getIntegerParam(P_Run, &run);

                printf("updateTime: %f, run: %d\n", updateTime, run);
                unlock();

                if (run) {
                        epicsEventWaitWithTimeout(eventId_, updateTime);
                }
                else{
                        printf("Wait for running signal\n");
                        epicsEventWait(eventId_);
                        printf("Receive the running signal\n");
                }

                lock();

                getIntegerParam(P_Run, &run);

                if (!run){
                        continue;
                }

                getIntegerParam(P_MaxPoints, &maxPoints);
                getDoubleParam(P_TimePerDiv, &timePerDiv);
                getDoubleParam(P_VoltsPerDiv, &voltsPerDiv);
                getDoubleParam(P_VoltOffset, &voltOffset);
                getDoubleParam(P_TriggerDelay, &triggerDelay);
                getDoubleParam(P_NoiseAmplitude, &noiseAmplitude);

                getDoubleParam(P_UpdateTime, &updateTime);
                printf("maxpoints:%d, timeperdiv:%f, voltsPerDiv:%f, voltoffset:%f, triggerdelay:%f, noiseampitude:%f, updatetime:%f\n",
                                maxPoints, timePerDiv, voltsPerDiv, voltOffset, triggerDelay, noiseAmplitude, updateTime);
                time = triggerDelay;
                timeStep = timePerDiv * NUM_DIVISIONS / maxPoints;
                minValue = 1e6;
                maxValue = -1e6;
                meanValue = 0.;

                yScale = 1.0 / voltsPerDiv;
                printf("timeStep:%f\n", timeStep);

                for (i = 0; i < maxPoints; i++){
                        noise = noiseAmplitude * (rand() / (double)RAND_MAX - 0.5);
                        pData_[i] = AMPLITUDE * (sin(time * FREQUENCY * 2 * pi)) + noise;
                        if (pData_[i] < minValue){
                                minValue = pData_[i];
                        }
                        if (pData_[i] > maxValue){
                                maxValue = pData_[i];
                        }
                        meanValue += pData_[i];
                        pData_[i] = NUM_DIVISIONS / 2 + yScale * (pData_[i] + voltOffset);
                        time += timeStep;
                }

                updateTimeStamp();
                meanValue = meanValue / maxPoints;

                setDoubleParam(P_MinValue, minValue);
                setDoubleParam(P_MaxValue, maxValue);
                setDoubleParam(P_MeanValue, meanValue);

                printf("min:%f, max:%f, mean:%f\n", minValue, maxValue, meanValue);
                callParamCallbacks();
                doCallbacksFloat64Array(pData_, maxPoints, P_Waveform, 0);
        }
}

void simTask(void * drvPvt)
{
        simScope * pPvt = (simScope *)drvPvt;
        pPvt->simTask();
}


extern "C"{
int simScopeConfigure(const char * portName, int maxPoints)
{
        new simScope(portName, maxPoints);
        return asynSuccess;
}

static const iocshArg initArg0 = {"portName", iocshArgString};
static const iocshArg initArg1 = {"max points", iocshArgInt};
static const iocshArg * const initArgs[] = {&initArg0, &initArg1};

static const iocshFuncDef initFuncDef = {"simScopeConfigure", 2, initArgs};

static void initCallFunc(const iocshArgBuf * args)
{
        simScopeConfigure(args[0].sval, args[1].ival);
}

void simScopeRegister(void)
{
        iocshRegister(&initFuncDef, initCallFunc);
}

epicsExportRegistrar(simScopeRegister);
}

c)  simScopeSupport.dbd：

registrar("simScopeRegister")

d) 修改所编写源文件目录下的Makefile文件，指定需要链接的库文件以及源文件及支持文件：

TOP=../..

include $(TOP)/configure/CONFIG
#----------------------------------------
#  ADD MACRO DEFINITIONS AFTER THIS LINE
#=============================

#=============================
# Build the IOC application

PROD_IOC = simScope
# simScope.dbd will be created and installed
DBD += simScope.dbd

# simScope.dbd will be made up from these files:
simScope_DBD += base.dbd
simScope_DBD += simScopeSupport.dbd

# Include dbd files from all support applications:
simScope_DBD += asyn.dbd

# Add all the support libraries needed by this IOC
simScope_LIBS += asyn


simScope_SRCS += simScope.cpp
# simScope_registerRecordDeviceDriver.cpp derives from simScope.dbd
simScope_SRCS += simScope_registerRecordDeviceDriver.cpp

# Build the main IOC entry point on workstation OSs.
simScope_SRCS_DEFAULT += simScopeMain.cpp
simScope_SRCS_vxWorks += -nil-

# Add support from base/src/vxWorks if needed
#simScope_OBJS_vxWorks += $(EPICS_BASE_BIN)/vxComLibrary

# Finally link to the EPICS Base libraries
simScope_LIBS += $(EPICS_BASE_IOC_LIBS)

#===========================

include $(TOP)/configure/RULES
#----------------------------------------
#  ADD RULES AFTER THIS LINE

4） 3) 进入simScopeApp/Db/目录下下编写记录支持数据库文件simScope.db并且将其添加到相同路径下的Makefile文件中：

# These records control run/stop --> P_Run
record(bo, "$(P)$(R)Run")
{
        field(PINI,     "1")
        field(DTYP,     "asynInt32")
        field(OUT,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_RUN")
        field(ZNAM,     "Stop")
        field(ONAM,     "Run")
}

record(bi, "$(P)$(R)Run_RBV")
{
        field(PINI,     "1")
        field(DTYP,     "asynInt32")
        field(INP,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_RUN")
        field(ZNAM,     "Done")
        field(ONAM,     "Running")
        field(OSV,      "MINOR")
        field(SCAN,     "I/O Intr")
}

## This record is the number of points in the data array ---> P_MaxPoints
## readonly, set in startup
record(longin, "$(P)$(R)MaxPoints_RBV")
{
        field(PINI,     "1")
        field(DTYP,     "asynInt32")
        field(INP,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_MAX_POINTS")
        field(SCAN,     "I/O Intr")
}

# There recrods are the choices for the Time Per Div Select ---> P_TimePerDivSelect
record(mbbo, "$(P)$(R)TimePerDivSelect")
{
        field(PINI,     "1")
        field(DTYP,     "asynInt32")
        field(OUT,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_TIME_PER_DIV_SELECT")
        field(ZRST,     "0.01 msec")
        field(ZRVL,     "10")
        field(ONST,     "0.02 msec")
        field(ONVL,     "20")
        field(TWST,     "0.05 msec")
        field(TWVL,     "50")
        field(THST,     "0.1 msec")
        field(THVL,     "100")
        field(FRST,     "0.2 msec")
        field(FRVL,     "200")
        field(FVST,     "0.5 msec")
        field(FVVL,     "500")
        field(SXST,     "1 msec")
        field(SXVL,     "1000")
        field(SVST,     "2 msec")
        field(SVVL,     "2000")
        field(EIST,     "5 msec")
        field(EIVL,     "5000")
        field(NIST,     "10 msec")
        field(NIVL,     "10000")
        field(TEST,     "20 msec")
        field(TEVL,     "20000")
        field(ELST,     "50 msec")
        field(ELVL,     "50000")
        field(TVST,     "100 msec")
        field(TVVL,     "100000")
}
#
## P_TimePerDiv
record(ai, "$(P)$(R)TimePerDiv_RBV")
{
        field(PINI,     "1")
        field(DTYP,     "asynFloat64")
        field(INP,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_TIME_PER_DIV")
        field(PREC,     "5")
        field(SCAN,     "I/O Intr")
}
#
## These records is for Vert Gain
## P_VertGainSelect
record(mbbo,    "$(P)$(R)VertGainSelect")
{
        field(PINI,     "1")
        field(DTYP,     "asynInt32")
        field(OUT,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_VERT_GAIN_SELECT")
        field(ZRST,     "1 X")
        field(ZRVL,     "1")
        field(ONST,     "2 X")
        field(ONVL,     "2")
        field(TWST,     "5 X")
        field(TWVL,     "5")
        field(THST,     "10 X")
        field(THVL,     "10")
        field(FRST,     "100 X")
        field(FRVL,     "100")
}

# P_VertGain
record(ai,      "$(P)$(R)VertGain_RBV")
{
        field(PINI,     "1")
        field(INP,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_VERT_GAIN")
        field(DTYP,     "asynFloat64")
        field(PREC,     "1")
        field(SCAN,     "I/O Intr")
}
#
#
record(mbbo, "$(P)$(R)VoltsPerDivSelect")
{
   field(PINI, "1")
   field(DTYP, "asynInt32")
   field(OUT,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))SCOPE_VOLTS_PER_DIV_SELECT")
   field(ZRST, "Garbage")
   field(ZRVL, "0")
}
#
record(mbbi, "$(P)$(R)VoltsPerDivSelect_RBV")
{
   field(DTYP, "asynInt32")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))SCOPE_VOLTS_PER_DIV_SELECT")
   field(ZRST, "Garbage")
   field(ZRVL, "0")
   field(SCAN, "I/O Intr")
}
#
record(ai, "$(P)$(R)VoltsPerDiv_RBV")
{
   field(PINI, "1")
   field(DTYP, "asynFloat64")
   field(INP,  "@asyn($(PORT),$(ADDR),$(TIMEOUT))SCOPE_VOLTS_PER_DIV")
   field(PREC, "2")
   field(SCAN, "I/O Intr")
}
## This record to set the offset
## P_VoltOffset
record(ao,      "$(P)$(R)VoltOffset")
{
        field(PINI,     "1")
        field(DTYP,     "asynFloat64")
        field(OUT,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_VOLT_OFFSET")
        field(PREC,     "3")
}

record(ai,      "$(P)$(R)VoltOffset_RBV")
{
        field(PINI,     "1")
        field(DTYP,     "asynFloat64")
        field(INP,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_VOLT_OFFSET")
        field(PREC,     "3")
        field(SCAN,     "I/O Intr")
}

# This record to set trigger delay time
record(ao,      "$(P)$(R)TriggerDelay")
{
        field(PINI,     "1")
        field(DTYP,     "asynFloat64")
        field(OUT,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_TRIGGER_DELAY")
        field(PREC,     "5")
}

record(ai,      "$(P)$(R)TriggerDelay_RBV")
{
        field(PINI,     "1")
        field(DTYP,     "asynFloat64")
        field(INP,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_TRIGGER_DELAY")
        field(PREC,     "5")
        field(SCAN,     "I/O Intr")
}

# This record to control noise in the signal
# P_NoiseAmplitude
record(ao,      "$(P)$(R)NoiseAmplitude")
{
        field(PINI,     "1")
        field(DTYP,     "asynFloat64")
        field(OUT,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_NOISE_AMPLITUDE")
        field(PREC,     "3")
}


record(ai,      "$(P)$(R)NoiseAmplitude_RBV")
{
        field(PINI,     "1")
        field(DTYP,     "asynFloat64")
        field(INP,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_NOISE_AMPLITUDE")
        field(PREC,     "3")
        field(SCAN,     "I/O Intr")
}
#
# This record to control the update time
record(ao,      "$(P)$(R)UpdateTime")
{
        field(PINI,     "1")
        field(DTYP,     "asynFloat64")
        field(OUT,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_UPDATE_TIME")
        field(PREC,     "3")
}

record(ai,      "$(P)$(R)UpdateTime_RBV")
{
        field(PINI,     "1")
        field(DTYP,     "asynFloat64")
        field(INP,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_UPDATE_TIME")
        field(PREC,     "3")
        field(SCAN,     "I/O Intr")
}

# This record is waveform
record(waveform,        "$(P)$(R)Waveform_RBV")
{
        field(PINI,     "1")
        field(DTYP,     "asynFloat64ArrayIn")
        field(INP,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_WAVEFORM")
        field(NELM,     "$(NPOINTS)")
        field(FTVL,     "DOUBLE")
        field(LOPR,     "0")
        field(HOPR,     "10")
        field(SCAN,     "I/O Intr")
}

# This record is time base
record(waveform,        "$(P)$(R)TimeBase_RBV")
{
        field(PINI,     "1")
        field(DTYP,     "asynFloat64ArrayIn")
        field(INP,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_TIME_BASE")
        field(NELM,     "$(NPOINTS)")
        field(FTVL,     "DOUBLE")
        field(LOPR,     "0")
        field(HOPR,     "10")
        field(SCAN,     "I/O Intr")
}

# This record is min value
record(ai,      "$(P)$(R)MinValue_RBV")
{
        field(PINI,     "1")
        field(DTYP,     "asynFloat64")
        field(INP,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_MIN_VALUE")
        field(PREC,     "4")
        field(SCAN,     "I/O Intr")
}


record(ai,      "$(P)$(R)MaxValue_RBV")
{
        field(PINI,     "1")
        field(DTYP,     "asynFloat64")
        field(INP,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_MAX_VALUE")
        field(PREC,     "4")
        field(SCAN,     "I/O Intr")
}

record(ai,      "$(P)$(R)MeanValue_RBV")
{
        field(PINI,     "1")
        field(DTYP,     "asynFloat64")
        field(INP,      "@asyn($(PORT), $(ADDR), $(TIMEOUT))SCOPE_MEAN_VALUE")
        field(PREC,     "4")
        field(SCAN,     "I/O Intr")
}

Makefile中添加：DB += simScope.db

5）回到这个IOC的顶层目录，即：simScope，执行make命令，进行程序编译。

6）进入启动目录iocBoot/iocsimScope，修改启动脚本文件st.cmd：

#!../../bin/linux-aarch64/simScope

#- You may have to change simScope to something else
#- everywhere it appears in this file

< envPaths

cd "${TOP}"

## Register all support components
dbLoadDatabase "dbd/simScope.dbd"
simScope_registerRecordDeviceDriver pdbbase
simScopeConfigure("testSimScope", 1000)

## Load record instances
dbLoadRecords("db/simScope.db","P=SimScope:,R=Device1:,PORT=testSimScope,ADDR=0,TIMEOUT=1, NPOINTS=1000")

cd "${TOP}/iocBoot/${IOC}"
iocInit

7） 启动这个IOC程序：

../../bin/linux-aarch64/simScope st.cmd

8） 查看这个IOC下的所有加载记录：

epics> dbl
SimScope:Device1:TimePerDiv_RBV
SimScope:Device1:VertGain_RBV
SimScope:Device1:VoltsPerDiv_RBV
SimScope:Device1:VoltOffset_RBV
SimScope:Device1:TriggerDelay_RBV
SimScope:Device1:NoiseAmplitude_RBV
SimScope:Device1:UpdateTime_RBV
SimScope:Device1:MinValue_RBV
SimScope:Device1:MaxValue_RBV
SimScope:Device1:MeanValue_RBV
SimScope:Device1:VoltOffset
SimScope:Device1:TriggerDelay
SimScope:Device1:NoiseAmplitude
SimScope:Device1:UpdateTime
SimScope:Device1:Run_RBV
SimScope:Device1:Run
SimScope:Device1:MaxPoints_RBV
SimScope:Device1:VoltsPerDivSelect_RBV
SimScope:Device1:TimePerDivSelect
SimScope:Device1:VertGainSelect
SimScope:Device1:VoltsPerDivSelect
SimScope:Device1:Waveform_RBV
SimScope:Device1:TimeBase_RBV

9） 使用CSS显示以上运行的记录数据库：

在Settings区域，可以选择设置垂直增益，每个刻度电压值，电压偏移，触发延时，正弦波更新周期，以及每个水平刻度表示的时间量。

在User Operate区域中，可以启动/停止波形的产生。

在Running Status区域可以显示运行状态。

在Statics Info区域中显示波形数据的统计信息。

EPICS Technical
关注
专栏目录
正弦波代码
04-22
在KEIL中编写的C程序，可实现简单的SPWM，可以借鉴一下。
WinAPI——模拟正弦波
weixin_30319153的博客
06-28 273
1 /*************************** 2 * 3 * 程序名称 ： 模拟正弦波 4 * 作 者 ： doodle777 5 * 版 本 ： 1.1 6 * 日 期 ： 2012-10-19 7 * 说 明 ： 1.1--解决了闪屏问题 8 * 9 *******...
正弦波产生C语言源程序代码
07-14
可以产生正弦波的C语言源程序代码，波形相当不错
d a转换正弦波c语言程序,C语言产生正弦波程序
weixin_42581003的博客
05-18 825
#includeint main (){int i;float s;for(i=0;i<256;i++){s=sin(atan(1)*8*i/256);printf("%d : %d;\n",i,(int)((s+1)*255/2));}return 0;}output:0 : 127;1 : 130;2 : 133;3 : 136;4 : 139;5 : 143;6 : 146;7 : 1...
正弦波显示程序
斑竹的程序设计专栏
10-29 3113
正弦波显示程序编一个正弦波显示程序#include#include#define PI 3.14159main(){int gd=VGA,gm=VGAHI,bkcolor=BLACK,color=YELLOW;double al,l,a;int x,y,py;initgraph(&gd,&gm,"c://tc");setbkcolor(bkcolor);setcolor(color);line(0
正弦波-方波信号发生器200Hz-20kHz-3_方波发生_multisim_正弦波发生器_信号发生器_仿真_
10-04
首先，正弦波发生器通常基于振荡电路实现，比如LC振荡器或RC振荡器。这些振荡器可以通过改变电感（L）或电容（C）的值来调整输出频率。在Multisim中，我们可以选择预设的振荡器元件，通过参数调整来设置所需的频率...
51单片机正弦波发生器（protues仿真+程序）.zip
04-08
本项目基于51单片机设计了一个正弦波发生器，结合了C51编程语言以及DA（数模转换）芯片，通过Protues软件进行仿真实现，提供了正弦波频率和幅度的可控性。 51单片机是市面上广泛应用的8位微控制器，它以其简单易用...
STM32仿真+程序正弦波信号发生器
12-20
本项目聚焦于STM32的仿真与程序开发，目标是实现一个正弦波信号发生器。在本文中，我们将深入探讨STM32的仿真环境、程序设计原理以及正弦波信号生成的技术细节。 一、STM32仿真环境 STM32的仿真通常依赖于两种工具...
频率可调的正弦波发生器电路图
08-08
本文将详细解析一种基于移相式的频率可调正弦波发生器电路，它具有极高的频率稳定度（0.002%），并且能够在宽频率范围内实现连续可调。电路设计简单，仅需少量低成本元件，同时具备了高性价比。 首先，电路的核心是...
DAC0832波形发生器protues仿真 正弦波 方波 三角波发生器仿真.zip
01-02
三角波发生器仿真是这个项目的关键部分。通常，三角波生成需要积分操作，这在数字域中可以通过递增或递减计数器模拟。在DAC0832中，通过控制输入数据的线性变化速率，可以实现从最小到最大再到最小的连续电压变化，...
matlab正弦波代码用源代码-MATLAB-Report-Generator:用几行代码生成MATLAB报告。不要浪费时间拍摄输出快照和复制
06-16
matlab正弦波代码用源代码MATLAB 报告生成器 为 Matlab 任务制作报告是一项乏味的任务。 这是一个示例教程，向您展示该项目是多么容易。 我们写了一些代码sine_wave.m现在我们想为它生成一个简单的报告 x = 0:pi/100:2*pi; y = sin(x); plot(x,y) 将此文件添加到“源代码”文件夹并在 Matlab 中运行它。 （您可以为文件指定任何名称） startt("MyReport") heading("Task 1") paragraph("Plot a sine wave") code("sine_wave") codeoutput("sine_wave") endd() 就是这样。 报告将存储在文件夹“Matlab Reports Here”中，文件名为“MyReport.docx”
matlab正弦函数程序代码-Reservoir_computing:在可重新编程的模拟硬件上实现Echo状态网络来模拟深度学习任务
06-07
matlab正弦函数程序代码水库计算项目 作者： Bertrand Thia-Thiong-Fat、Yassine Kamri 该存储库展示了我们在 FPAA（现场可编程模拟阵列）上实施深度学习任务的工作结果。 我们基于佐治亚理工学院的 DC RASP3.0A FPAA 平台模拟了一台水库计算机，以验证各种经验——然后在板上重现它们。 我们的模拟器在两个深度学习任务上的表现可以在这里找到：正弦波发生器和口语数字识别任务。 目录和文件 ActivationFunction ：包含团队使用模拟板（带有电阻器、电容器和运算放大器）生成的不同激活函数的数据点和可视化。 AuditoryToolbox ：Matlab 模块，用于为数字语音识别任务预处理我们的数据。 Example ：可以运行一个简单的示例来观察我们在数字语音识别任务上的结果。 preprocessing ：用于使用耳蜗技术对数字语音识别任务的数据进行preprocessing代码。 references-papers ：我们工作中使用的参考文献和论文。 report.pdf ：我们的工作报告。 SinuxExpo ：用于在正弦波
C语言 正玄波代码
enfang1120的博客
10-11 1296
#define PointLine 3 #define PointMax 512 #define PI 3.141592654f float sinData[PointLine][PointMax] = {0}; void get_sin_tab(unsigned int point, unsigned int maxnum) { unsigned int i = 0, j = 0, k = 0; float hd = 0.0f; //弧度 float fz = 0.0f; //峰...
51单片机生成模拟正弦波
腹有诗词气自华
04-01 4432
最后就是编译成hex文件，导入proteus中，仿真运行，就能得到下面的正弦波形了。最后编译成hex文件导入proteus中模拟运行就得到下图的三角波波形了。然后编写c程序，看下面的代码。经过测试了，可以放心使用。首先打开proteus软件，如图导入各个元器件，并连线。下面在写一个怎么生成三角波形的程序。程序代码看下面，很简单的。
用正点原子的Mini32生成正弦波代码
一只兔子
03-11 623
主要是在原始例程上对main.c进行修改 增加关于正弦函数的代码 生成相应的点 接下来附上相应的代码程序 //输出正弦波函数 void dac_sin_out(u8 dots) { u8 i; u16 buf[255]; float inc=2PI/dots; //计算增量（一个周期dots个点） float outdata=0; for(i=0;i<dots;i++) { outda...
单片机输出正弦波c语言程序,MSP430单片机片内12位DA产生正弦波C语言程序
weixin_34362937的博客
05-18 1234
#include//------------------------------------------------------------------------------// 12-bit Sine Lookup table with 32 steps//-------------------------------------------------------------------...
c语言写了一个简单的正弦波函数
热门推荐
chenyujing1234的专栏
04-04 1万+
转载自 http://blog.csdn.net/qiongguishanglu/article/details/5874251   #include #include #include #define FQ 1000 #define AM 1000 #define PI 3.14 int main() { FILE *stream; int i=0,j=0; doub
da正弦波c语言程序,单片机DA转换实现正弦波
weixin_34580939的博客
05-24 1328
使用的是查表法：1.c文件：#include "reg52.h"#include#include#define PCF8591 0x90#define uint unsigned int#define uchar unsigned char#define arr_length 720 //正弦波数组长度code unsigned char sin1[720]={0x80,0x81,0x82,0x...
Linux 之 信号概念、进程、进程间通信、线程、线程同步
最新发布
挥剑决浮云的博客
11-01 418
如果释放互斥锁时有一个以上的线程阻塞，那么这些阻塞的线程会被唤醒，它们都会尝试对互斥锁进行加锁，当有一个线程成功对互斥锁上锁之后，其它线程就不能再次上锁了，只能再次陷入阻塞，等待下一次解锁。事实上，子进程是父进程的一个副本，譬如子进程拷贝了父进程的数据段、堆、栈以及继承了父进程打开的文件描述符，父进程与子进程并不共享这些存储空间，这是子进程对父进程相应部分存储空间的完全复制，执行fork()之后，每个进程均可修改各自的栈数据以及堆段中的变量，而并不影响另一个进程。是一族函数，而不是一个单独的函数。
Multisim仿真：正弦波振荡器设计与参数计算
这种电路在通信系统、测试仪器和工业应用中都有广泛应用，如无线电发射设备、超外差式接收机、信号发生器和数字式频率计等。 振荡器的基本构成包含三个主要部分：放大器、正反馈电路和选频网络。放大器的作用是放大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值