cphidgetfrequencycounter.c

Go to the documentation of this file.

#include "stdafx.h"
#include "cphidgetfrequencycounter.h"
#include <math.h>
#include "cusb.h"
#include "csocket.h"
#include "cthread.h"

// === Internal Functions === //

//clearVars - sets all device variables to unknown state
CPHIDGETCLEARVARS(FrequencyCounter)
        int i = 0;

        //initialize triggers, set data arrays to unknown
        for (i = 0; i<FREQCOUNTER_MAXINPUTS; i++)
        {
                phid->timeout[i] = PUNI_INT;
                phid->frequency[i] = PUNI_INT;
                phid->filterEcho[i] = PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_UNKNOWN;
                phid->enabledEcho[i] = PUNI_BOOL;

                phid->totalCount[i] = 0;
                phid->totalTime[i] = 0;

                phid->countsGood[i] = PFALSE;
        }

        return EPHIDGET_OK;
}

//initAfterOpen - sets up the initial state of an object, reading in packets from the device if needed
//                                used during attach initialization - on every attach
CPHIDGETINIT(FrequencyCounter)
        int i;

        TESTPTR(phid);

        //initialize triggers, set data arrays to unknown
        for (i = 0; i<phid->phid.attr.frequencycounter.numFreqInputs; i++)
        {
                phid->timeout[i] = 1000000; //1 second (in microseconds) - detect down to 1Hz

                phid->frequency[i] = PUNK_INT;
                phid->filterEcho[i] = PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_UNKNOWN;
                phid->enabledEcho[i] = PUNK_BOOL;
        }
        phid->lastPacketCount = PUNK_INT;

        //issue one read
        CPhidget_read((CPhidgetHandle)phid);

        //fill in enabledState and filterType, set other things to 0
        for (i = 0; i<phid->phid.attr.frequencycounter.numFreqInputs; i++)
        {
                phid->filter[i] = phid->filterEcho[i];
                phid->enabled[i] = phid->enabledEcho[i];
                
                phid->totalTicksSinceLastCount[i] = PUNK_INT;

                phid->totalCount[i] = 0;
                phid->totalTime[i] = 0;
        }
        phid->lastPacketCount = PUNK_INT;

        return EPHIDGET_OK;
}

//dataInput - parses device packets
CPHIDGETDATA(FrequencyCounter)
        int i, packetCount;
        int ticks, ticksAtLastCount[FREQCOUNTER_MAXINPUTS], counts[FREQCOUNTER_MAXINPUTS];
        char error_buffer[127];

        //Setup max/min values
        switch(phid->phid.deviceIDSpec)
        {
                case PHIDID_FREQUENCYCOUNTER_2INPUT:
                        if(phid->phid.deviceVersion < 200) 
                        {
                                ticks = buffer[0] + (buffer[1] << 8);

                                counts[0] = buffer[2] + (buffer[3] << 8) + (buffer[4] << 16);
                                ticksAtLastCount[0] = buffer[5] + (buffer[6] << 8);

                                counts[1] = buffer[7] + (buffer[8] << 8) + (buffer[9] << 16);
                                ticksAtLastCount[1] = buffer[10] + (buffer[11] << 8);

                                //Filter type echo
                                if(buffer[12] & FREQCOUNTER_FLAG_CH0_LOGIC)
                                        phid->filterEcho[0] = PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_LOGIC_LEVEL;
                                else
                                        phid->filterEcho[0] = PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_ZERO_CROSSING;
                                if(buffer[12] & FREQCOUNTER_FLAG_CH1_LOGIC)
                                        phid->filterEcho[1] = PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_LOGIC_LEVEL;
                                else
                                        phid->filterEcho[1] = PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_ZERO_CROSSING;
                                
                                //Enabled state echo
                                if(buffer[12] & FREQCOUNTER_FLAG_CH0_ENABLE)
                                        phid->enabledEcho[0] = PTRUE;
                                else
                                        phid->enabledEcho[0] = PFALSE;
                                if(buffer[12] & FREQCOUNTER_FLAG_CH1_ENABLE)
                                        phid->enabledEcho[1] = PTRUE;
                                else
                                        phid->enabledEcho[1] = PFALSE;

                                packetCount = (buffer[12] & 0xF0) >> 4;
                        }
                        else
                                return EPHIDGET_UNEXPECTED;
                        break;
                default:
                        return EPHIDGET_UNEXPECTED;
        }

        if((phid->lastPacketCount != PUNK_INT) && ((phid->lastPacketCount+1)&0x0F) != packetCount)
        {
                FIRE_ERROR_NOQUEUE(EEPHIDGET_PACKETLOST, "One or more data packets were lost");
        }
        phid->lastPacketCount = packetCount;

        for(i=0;i<phid->phid.attr.frequencycounter.numFreqInputs; i++)
        {
                if(phid->enabledEcho[i] == PTRUE && phid->enabled[i] == PTRUE)
                {
                        CThread_mutex_lock(&phid->resetlock);
                        phid->totalTime[i] += (ticks * FREQCOUNTER_MICROSECONDS_PER_TICK);
                        phid->totalCount[i] += counts[i];
                        CThread_mutex_unlock(&phid->resetlock);

                        if (counts[i] == 0)
                        {
                                //Do not accumulate if timed out
                                if (phid->totalTicksSinceLastCount[i] != PUNK_INT)
                                        phid->totalTicksSinceLastCount[i] += ticks;

                                //only accumulate counts up to timeOut
                                if ((phid->totalTicksSinceLastCount[i] * FREQCOUNTER_MICROSECONDS_PER_TICK) > phid->timeout[i])
                                {
                                        phid->frequency[i] = 0;

                                        //Fire one event with 0 counts to indicate that the Timeout has elapsed and frequency is now 0
                                        FIRE(Count, i, (phid->totalTicksSinceLastCount[i] * FREQCOUNTER_MICROSECONDS_PER_TICK), 0);
                                        phid->totalTicksSinceLastCount[i] = PUNK_INT;
                                }
                        }
                        else
                        {
                                //1st count(s) since a timeout (or 1st read packet since opening)
                                //don't try to calculate frequency because we don't to the 'ticks at first count'
                                if (phid->totalTicksSinceLastCount[i] == PUNK_INT)
                                {
                                        phid->totalTicksSinceLastCount[i] = ticks - ticksAtLastCount[i];
                                }
                                else
                                {
                                        int countTimeSpan = (phid->totalTicksSinceLastCount[i] + ticksAtLastCount[i]) * FREQCOUNTER_MICROSECONDS_PER_TICK; //in microseconds
                                        phid->frequency[i] = (double)((double)counts[i] / ((double)countTimeSpan / 1000000.0));

                                        FIRE(Count, i, countTimeSpan, counts[i]);

                                        phid->totalTicksSinceLastCount[i] = ticks - ticksAtLastCount[i];
                                }
                        }
                }
                else
                        phid->frequency[i] = PUNK_DBL;
        }

        return EPHIDGET_OK;
}

//eventsAfterOpen - sends out an event for all valid data, used during attach initialization
CPHIDGETINITEVENTS(FrequencyCounter)
        phid = 0;
        return EPHIDGET_OK;
}

//Extra things to do during a free
//This is run before the other things that free does
int CPhidgetFrequencyCounter_free(CPhidgetHandle phidG)
{
        CPhidgetFrequencyCounterHandle phid = (CPhidgetFrequencyCounterHandle)phidG;
        CThread_mutex_destroy(&phid->resetlock);
        return EPHIDGET_OK;
}

//getPacket - used by write thread to get the next packet to send to device
CGETPACKET_BUF(FrequencyCounter)

//sendpacket - sends a packet to the device asynchronously, blocking if the 1-packet queue is full
CSENDPACKET_BUF(FrequencyCounter)

//makePacket - constructs a packet using current device state
CMAKEPACKET(FrequencyCounter)
        TESTPTRS(phid, buffer);

        //Setup max/min values
        switch(phid->phid.deviceIDSpec)
        {
                case PHIDID_FREQUENCYCOUNTER_2INPUT:
                        if(phid->phid.deviceVersion < 200) 
                        {
                                buffer[0] = 0;
                                if(phid->enabled[0] == PTRUE)
                                        buffer[0] |= FREQCOUNTER_FLAG_CH0_ENABLE;
                                else
                                        phid->enabled[0] = PFALSE;
                                if(phid->filter[0] == PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_LOGIC_LEVEL)
                                        buffer[0] |= FREQCOUNTER_FLAG_CH0_LOGIC;
                                else
                                        phid->filter[0] = PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_ZERO_CROSSING;

                                if(phid->enabled[1] == PTRUE)
                                        buffer[0] |= FREQCOUNTER_FLAG_CH1_ENABLE;
                                else
                                        phid->enabled[1] = PFALSE;
                                if(phid->filter[1] == PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_LOGIC_LEVEL)
                                        buffer[0] |= FREQCOUNTER_FLAG_CH1_LOGIC;
                                else
                                        phid->filter[1] = PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_ZERO_CROSSING;
                        }
                        else
                                return EPHIDGET_UNEXPECTED;
                        break;
                default:
                        return EPHIDGET_UNEXPECTED;
        }
        return EPHIDGET_OK;
}

// === Exported Functions === //

//create and initialize a device structure
CCREATE_EXTRA(FrequencyCounter, PHIDCLASS_FREQUENCYCOUNTER)
        CThread_mutex_init(&phid->resetlock);
        phid->phid.fptrFree = CPhidgetFrequencyCounter_free;
        return EPHIDGET_OK;
}

//event setup functions
CFHANDLE(FrequencyCounter, Count, int, int, int)

CGET(FrequencyCounter,FrequencyInputCount,int)
        TESTPTRS(phid,pVal) 
        TESTDEVICETYPE(PHIDCLASS_FREQUENCYCOUNTER)
        TESTATTACHED

        MASGN(phid.attr.frequencycounter.numFreqInputs)
}

CGETINDEX(FrequencyCounter,Frequency,double)
        TESTPTRS(phid,pVal) 
        TESTDEVICETYPE(PHIDCLASS_FREQUENCYCOUNTER)
        TESTATTACHED
        TESTINDEX(phid.attr.frequencycounter.numFreqInputs)
        TESTMASGN(frequency[Index], PUNK_DBL)

        MASGN(frequency[Index])
}

CGETINDEX(FrequencyCounter,TotalTime,__int64)
        TESTPTRS(phid,pVal)
        TESTDEVICETYPE(PHIDCLASS_FREQUENCYCOUNTER)
        TESTATTACHED
        TESTINDEX(phid.attr.frequencycounter.numFreqInputs)

        MASGN(totalTime[Index])
}

CGETINDEX(FrequencyCounter,TotalCount,__int64)
        TESTPTRS(phid,pVal)
        TESTDEVICETYPE(PHIDCLASS_FREQUENCYCOUNTER)
        TESTATTACHED
        TESTINDEX(phid.attr.frequencycounter.numFreqInputs)

        MASGN(totalCount[Index])
}

CGETINDEX(FrequencyCounter,TotalTime32,int)
        TESTPTRS(phid,pVal)
        TESTDEVICETYPE(PHIDCLASS_FREQUENCYCOUNTER)
        TESTATTACHED
        TESTINDEX(phid.attr.frequencycounter.numFreqInputs)

        *pVal = (int)phid->totalTime[Index]; return EPHIDGET_OK;
}

CGETINDEX(FrequencyCounter,TotalCount32,int)
        TESTPTRS(phid,pVal)
        TESTDEVICETYPE(PHIDCLASS_FREQUENCYCOUNTER)
        TESTATTACHED
        TESTINDEX(phid.attr.frequencycounter.numFreqInputs)

        *pVal = (int)phid->totalCount[Index]; return EPHIDGET_OK;
}

CGETINDEX(FrequencyCounter,Timeout,int)
        TESTPTRS(phid,pVal)
        TESTDEVICETYPE(PHIDCLASS_FREQUENCYCOUNTER)
        TESTATTACHED
        TESTINDEX(phid.attr.frequencycounter.numFreqInputs)

        MASGN(timeout[Index])
}
CSETINDEX(FrequencyCounter,Timeout,int)
        TESTPTR(phid)
        TESTDEVICETYPE(PHIDCLASS_FREQUENCYCOUNTER)
        TESTATTACHED
        TESTRANGE(100000, 100000000) //0.1-100 seconds
        TESTINDEX(phid.attr.frequencycounter.numFreqInputs)

        if(CPhidget_statusFlagIsSet(phid->phid.status, PHIDGET_REMOTE_FLAG))
                ADDNETWORKKEYINDEXED(Timeout, "%d", timeout);
        else
                SENDPACKET(FrequencyCounter, timeout[Index]);

        return EPHIDGET_OK;
}

CGETINDEX(FrequencyCounter,Enabled,int)
        TESTPTRS(phid,pVal)
        TESTDEVICETYPE(PHIDCLASS_FREQUENCYCOUNTER)
        TESTATTACHED
        TESTINDEX(phid.attr.frequencycounter.numFreqInputs)
        TESTMASGN(enabledEcho[Index], PUNK_BOOL)

        MASGN(enabledEcho[Index])
}
CSETINDEX(FrequencyCounter,Enabled,int)
        TESTPTR(phid)
        TESTDEVICETYPE(PHIDCLASS_FREQUENCYCOUNTER)
        TESTATTACHED
        TESTRANGE(PFALSE, PTRUE)
        TESTINDEX(phid.attr.frequencycounter.numFreqInputs)

        if(newVal == PFALSE) phid->frequency[Index] = PUNK_DBL;

        if(CPhidget_statusFlagIsSet(phid->phid.status, PHIDGET_REMOTE_FLAG))
                ADDNETWORKKEYINDEXED(Enabled, "%d", enabled);
        else
                SENDPACKET(FrequencyCounter, enabled[Index]);

        return EPHIDGET_OK;
}

CGETINDEX(FrequencyCounter,Filter,CPhidgetFrequencyCounter_FilterType)
        TESTPTRS(phid,pVal)
        TESTDEVICETYPE(PHIDCLASS_FREQUENCYCOUNTER)
        TESTATTACHED
        TESTINDEX(phid.attr.frequencycounter.numFreqInputs)
        TESTMASGN(filterEcho[Index], PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_UNKNOWN)

        MASGN(filterEcho[Index])
}
CSETINDEX(FrequencyCounter,Filter,CPhidgetFrequencyCounter_FilterType)
        TESTPTR(phid)
        TESTDEVICETYPE(PHIDCLASS_FREQUENCYCOUNTER)
        TESTATTACHED
        TESTRANGE(PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_ZERO_CROSSING, PHIDGET_FREQUENCYCOUNTER_FILTERTYPE_LOGIC_LEVEL)
        TESTINDEX(phid.attr.frequencycounter.numFreqInputs)

        if(CPhidget_statusFlagIsSet(phid->phid.status, PHIDGET_REMOTE_FLAG))
                ADDNETWORKKEYINDEXED(Filter, "%d", filter);
        else
                SENDPACKET(FrequencyCounter, filter[Index]);

        return EPHIDGET_OK;
}

PHIDGET21_API int CCONV CPhidgetFrequencyCounter_reset(CPhidgetFrequencyCounterHandle phid, int Index)
{
        TESTPTR(phid)
        TESTDEVICETYPE(PHIDCLASS_FREQUENCYCOUNTER)
        TESTATTACHED
        TESTINDEX(phid.attr.frequencycounter.numFreqInputs)

        if(CPhidget_statusFlagIsSet(phid->phid.status, PHIDGET_REMOTE_FLAG))
        {
                int newVal = phid->flip[Index]^1;
                ADDNETWORKKEYINDEXED(Reset, "%d", flip);
        }
        else
        {
                CThread_mutex_lock(&phid->resetlock);
                phid->totalCount[Index] = 0;
                phid->totalTime[Index] = 0;
                CThread_mutex_unlock(&phid->resetlock);
        }

        return EPHIDGET_OK;
}