示例#1
0
void wmr918GetReadings (WVIEWD_WORK *work)
{
    WMR918_IF_DATA*     ifWorkData = (WMR918_IF_DATA*)work->stationData;

    // populate the LOOP structure:
    ifWorkData->wmr918Readings = wmr918Work.sensorData;
    storeLoopPkt (work, &work->loopPkt, &ifWorkData->wmr918Readings);

    // indicate the LOOP packet is done
    radProcessEventsSend (NULL, STATION_LOOP_COMPLETE_EVENT, 0);
}
示例#2
0
// station-supplied function to indicate sensor readings should be performed -
// should populate 'work' struct: loopPkt (see datadefs.h for minimum field reqs)
// -- Can Be Asynchronous --
//
// - indicate readings are complete by sending the STATION_LOOP_COMPLETE_EVENT
//   event to this process (radProcessEventsSend (NULL, STATION_LOOP_COMPLETE_EVENT, 0))
//
// Returns: OK or ERROR
//
int stationGetReadings (WVIEWD_WORK *work)
{
    // we will do this synchronously...

    // populate the LOOP structure (with dummy data)
    storeLoopPkt (work, &work->loopPkt);

    // indicate we are done
    radProcessEventsSend (NULL, STATION_LOOP_COMPLETE_EVENT, 0);
    
    return OK;
}
示例#3
0
void wh1080GetReadings (WVIEWD_WORK *work)
{
    WH1080_IF_DATA*  ifWorkData = (WH1080_IF_DATA*)work->stationData;

    if (readStationData(work) == OK)
    {
        // populate the LOOP structure:
        ifWorkData->wh1080Readings = wh1080Work.sensorData;
        storeLoopPkt (work, &work->loopPkt, &ifWorkData->wh1080Readings);

        // indicate the LOOP packet is done
        radProcessEventsSend (NULL, STATION_LOOP_COMPLETE_EVENT, 0);
    }
}
示例#4
0
// station-supplied function to indicate sensor readings should be performed -
// should populate 'work' struct: loopPkt (see datadefs.h for minimum field reqs)
// -- Can Be Asynchronous --
//
// - indicate readings are complete by sending the STATION_LOOP_COMPLETE_EVENT
//   event to this process (radProcessEventsSend (NULL, STATION_LOOP_COMPLETE_EVENT, 0))
//
// Returns: OK or ERROR
//
int stationGetReadings (WVIEWD_WORK *work)
{
    // we will do this synchronously...

    // get readings from station
    if (virtualProtocolGetReadings(work, &virtualWorkData.virtualReadings) == OK)
    {
        // populate the LOOP structure
        storeLoopPkt(&work->loopPkt, &virtualWorkData);

        // indicate we are done
        radProcessEventsSend(NULL, STATION_LOOP_COMPLETE_EVENT, 0);
    }

    return OK;
}
示例#5
0
int wmr918Init (WVIEWD_WORK *work)
{
    WMR918_IF_DATA*     ifWorkData = (WMR918_IF_DATA*)work->stationData;
    fd_set              rfds;
    struct timeval      tv;
    int                 i, length, retVal;
    time_t              nowTime = time(NULL) - (WV_SECONDS_IN_HOUR/(60/WMR918_RAIN_RATE_PERIOD));
    ARCHIVE_PKT         recordStore;
    char                outString[128];

    memset (&wmr918Work, 0, sizeof(wmr918Work));

    // Create the rain accumulator (WMR918_RAIN_RATE_PERIOD minute age) 
    // so we can compute rain rate:
    ifWorkData->rainRateAccumulator = sensorAccumInit(WMR918_RAIN_RATE_PERIOD);

    // Populate the accumulator with the last WMR918_RAIN_RATE_PERIOD minutes:
    while ((nowTime = dbsqliteArchiveGetNextRecord(nowTime, &recordStore)) != ERROR)
    {
        sensorAccumAddSample(ifWorkData->rainRateAccumulator, 
                             recordStore.dateTime, 
                             recordStore.value[DATA_INDEX_rain]);
    }

    radMsgLog (PRI_MEDIUM, 
        "wmr918Init: waiting for first sensor packets (this may take some time):");
    while ((wmr918Work.dataRXMask != WMR918_SENSOR_ALL) && (! work->exiting))
    {
        // Log what we are waiting for:
        length = 0;
        for (i = 0; i < 4; i ++)
        {
            if (! (wmr918Work.dataRXMask & (1 << i)))
            {
                length += sprintf(&outString[length], "%s ", WMRSensorNames[i]);
            }
        }
        radMsgLog (PRI_MEDIUM, "wmr918Init: waiting for sensors: %s", outString);

        tv.tv_sec  = 2;
        tv.tv_usec = 0;

        FD_ZERO(&rfds);
        FD_SET(work->medium.fd, &rfds);
        if (select (work->medium.fd + 1, &rfds, NULL, NULL, &tv) > 0)
        {
            retVal = readStationData (work);
            switch (retVal)
            {
                case WMR918GROUP0:
                    radMsgLog (PRI_MEDIUM, "received WIND packet...");
                    break;
                case WMR918GROUP1:
                    radMsgLog (PRI_MEDIUM, "received RAIN packet...");
                    break;
                case WMR918GROUP2:
                    radMsgLog (PRI_MEDIUM, "received EXTRA TEMP packet...");
                    break;
                case WMR918GROUP3:
                    radMsgLog (PRI_MEDIUM, "received OUT TEMP packet...");
                    break;
                case WMR918GROUP4:
                    radMsgLog (PRI_MEDIUM, "received POOL TEMP packet...");
                    break;
                case WMR918GROUP5:
                case WMR918GROUP6:
                    radMsgLog (PRI_MEDIUM, "received IN TEMP packet...");
                    break;
                default:
                    break;
            }
        }
    }

    if (! work->exiting)
    {
        radMsgLog (PRI_MEDIUM, "wmr918Init: first sensor packets received.");
    }

    // populate the LOOP structure:
    ifWorkData->wmr918Readings = wmr918Work.sensorData;
    storeLoopPkt (work, &work->loopPkt, &ifWorkData->wmr918Readings);

    // we must indicate successful completion here -
    // even though we are synchronous, the daemon wants to see this event
    radProcessEventsSend (NULL, STATION_INIT_COMPLETE_EVENT, 0);

    return OK;
}
示例#6
0
// station-supplied init function
// -- Can Be Asynchronous - event indication required --
//
// MUST:
//   - set the 'stationGeneratesArchives' flag in WVIEWD_WORK:
//     if the station generates archive records (TRUE) or they should be
//     generated automatically by the daemon from the sensor readings (FALSE)
//   - Initialize the 'stationData' store for station work area
//   - Initialize the interface medium
//   - do initial LOOP acquisition
//   - do any catch-up on archive records if there is a data logger
//   - 'work->runningFlag' can be used for start up synchronization but should
//     not be modified by the station interface code
//   - indicate init is done by sending the STATION_INIT_COMPLETE_EVENT event to
//     this process (radProcessEventsSend (NULL, STATION_INIT_COMPLETE_EVENT, 0))
//
// OPTIONAL:
//   - Initialize a state machine or any other construct required for the
//     station interface - these should be stored in the 'stationData' store
//
// 'archiveIndication' - indication callback used to pass back an archive record
//   generated as a result of 'stationGetArchive' being called; should receive a
//   NULL pointer for 'newRecord' if no record available; only used if
//   'stationGeneratesArchives' flag is set to TRUE by the station interface
//
// Returns: OK or ERROR
//
int stationInit
(
    WVIEWD_WORK     *work,
    void            (*archiveIndication)(ARCHIVE_PKT* newRecord)
)
{
    int             i;
    time_t          nowTime = time(NULL) - (WV_SECONDS_IN_HOUR * 12);
    ARCHIVE_PKT     recordStore;
    ARCHIVE_PKT     newestRecord;
    char            tempStr[WVIEW_MAX_PATH];

    memset (&virtualWorkData, 0, sizeof(virtualWorkData));

    // save the archive indication callback (we should never need it)
    ArchiveIndicator = archiveIndication;

    // set our work data pointer
    work->stationData = &virtualWorkData;

    // set the Archive Generation flag to indicate the VIRTUAL DOES NOT
    // generate them
    work->stationGeneratesArchives = TRUE;

    // initialize the medium abstraction based on user configuration
    if (!strcmp (work->stationInterface, "serial"))
    {
        radMsgLog (PRI_HIGH, "stationInit: serial medium not supported for virtual station!");
        return ERROR;
    }
    else if (!strcmp (work->stationInterface, "ethernet"))
    {
        if (ethernetMediumInit (&work->medium, work->stationHost, work->stationPort)
            == ERROR)
        {
            radMsgLog (PRI_HIGH, "stationInit: ethernet MediumInit failed");
            return ERROR;
        }
    }
    else
    {
        radMsgLog (PRI_HIGH, "stationInit: medium %s not supported",
                   work->stationInterface);
        return ERROR;
    }

    // initialize the interface using the media specific routine
    if ((*(work->medium.init))(&work->medium, work->stationDevice) == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: medium setup failed");
        return ERROR;
    }

    // Make the socket blocking:
    radSocketSetBlocking ((*(work->medium.getsocket))(&work->medium), TRUE);

    // Reset the stationType to include the host:port:
    sprintf(tempStr, "%s:%s:%d", 
            work->stationType, work->stationHost, work->stationPort);
    wvstrncpy(work->stationType, tempStr, sizeof(work->stationType));

    if (!strcmp (work->stationInterface, "ethernet"))
    {
        radMsgLog (PRI_STATUS, "VIRTUAL on %s:%d opened ...",
                   work->stationHost, work->stationPort);
    }

    // grab the station configuration now
    if (stationGetConfigValueInt (work,
                                  STATION_PARM_ELEVATION,
                                  &virtualWorkData.elevation)
            == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: stationGetConfigValueInt ELEV failed!");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }
    if (stationGetConfigValueFloat (work,
                                    STATION_PARM_LATITUDE,
                                    &virtualWorkData.latitude)
            == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: stationGetConfigValueInt LAT failed!");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }
    if (stationGetConfigValueFloat (work,
                                    STATION_PARM_LONGITUDE,
                                    &virtualWorkData.longitude)
            == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: stationGetConfigValueInt LONG failed!");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }
    if (stationGetConfigValueInt (work,
                                  STATION_PARM_ARC_INTERVAL,
                                  &virtualWorkData.archiveInterval)
            == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: stationGetConfigValueInt ARCINT failed!");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }

    // set the work archive interval now
    work->archiveInterval = virtualWorkData.archiveInterval;

    // sanity check the archive interval against the most recent record
    if (stationVerifyArchiveInterval (work) == ERROR)
    {
        // bad magic!
        radMsgLog (PRI_HIGH, "stationInit: stationVerifyArchiveInterval failed!");
        radMsgLog (PRI_HIGH, "You must either move old archive data out of the way -or-");
        radMsgLog (PRI_HIGH, "fix the interval setting...");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }
    else
    {
        radMsgLog (PRI_STATUS, "station archive interval: %d minutes",
                   work->archiveInterval);
    }

    radMsgLog (PRI_STATUS, "Starting station interface: VIRTUAL"); 

    // This must be done here:
    work->archiveDateTime = dbsqliteArchiveGetNewestTime(&newestRecord);
    if ((int)work->archiveDateTime == ERROR)
    {
        work->archiveDateTime = 0;
        radMsgLog (PRI_STATUS, "stationInit: no archive records found in database!");
    }

    // initialize the station interface
    if (virtualProtocolInit(work) == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: virtualProtocolInit failed!");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }

    // do the initial GetReadings now
    if (virtualProtocolGetReadings(work, &virtualWorkData.virtualReadings) != OK)
    {
        radMsgLog (PRI_HIGH, "stationInit: initial virtualProtocolGetReadings failed!");
        virtualProtocolExit (work);
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }

    // populate the LOOP structure
    storeLoopPkt (&work->loopPkt, &virtualWorkData);

    // we must indicate successful completion here -
    // even though we are synchronous, the daemon wants to see this event
    radProcessEventsSend(NULL, STATION_INIT_COMPLETE_EVENT, 0);

    return OK;
}
示例#7
0
// station-supplied init function
// -- Can Be Asynchronous - event indication required --
//
// MUST:
//   - set the 'stationGeneratesArchives' flag in WVIEWD_WORK:
//     if the station generates archive records (TRUE) or they should be
//     generated automatically by the daemon from the sensor readings (FALSE)
//   - Initialize the 'stationData' store for station work area
//   - Initialize the interface medium
//   - do initial LOOP acquisition
//   - do any catch-up on archive records if there is a data logger
//   - 'work->runningFlag' can be used for start up synchronization but should
//     not be modified by the station interface code
//   - indicate init is done by sending the STATION_INIT_COMPLETE_EVENT event to
//     this process (radProcessEventsSend (NULL, STATION_INIT_COMPLETE_EVENT, 0))
//
// OPTIONAL:
//   - Initialize a state machine or any other construct required for the
//     station interface - these should be stored in the 'stationData' store
//
// 'archiveIndication' - indication callback used to pass back an archive record
//   generated as a result of 'stationGetArchive' being called; should receive a
//   NULL pointer for 'newRecord' if no record available; only used if
//   'stationGeneratesArchives' flag is set to TRUE by the station interface
//
// Returns: OK or ERROR
//
int stationInit
(
    WVIEWD_WORK     *work,
    void            (*archiveIndication)(ARCHIVE_PKT* newRecord)
)
{
    int             i;
    ARCHIVE_PKT     recordStore;
    time_t          nowTime;

    memset (&twiWorkData, 0, sizeof(twiWorkData));
    pwviewWork = work;
    twiWorkData.baudrate = B19200;

    // save the archive indication callback (we should never need it)
    ArchiveIndicator = archiveIndication;

    // set our work data pointer
    work->stationData = &twiWorkData;

    // set the Archive Generation flag to indicate the TWI DOES NOT
    // generate them
    work->stationGeneratesArchives = FALSE;

    // initialize the medium abstraction based on user configuration
    if (!strcmp (work->stationInterface, "serial"))
    {
        if (serialMediumInit (&work->medium, serialPortConfig, O_RDWR | O_NOCTTY | O_NDELAY) == ERROR)
        {
            radMsgLog (PRI_HIGH, "stationInit: serial MediumInit failed");
            return ERROR;
        }
    }
    else if (!strcmp (work->stationInterface, "ethernet"))
    {
        if (ethernetMediumInit (&work->medium, work->stationHost, work->stationPort)
                == ERROR)
        {
            radMsgLog (PRI_HIGH, "stationInit: ethernet MediumInit failed");
            return ERROR;
        }
    }
    else
    {
        radMsgLog (PRI_HIGH, "stationInit: medium %s not supported",
                   work->stationInterface);
        return ERROR;
    }

    // initialize the interface using the media specific routine
    if ((*(work->medium.init)) (&work->medium, work->stationDevice) == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: medium setup failed");
        return ERROR;
    }

    // Autobaud the station now:
    twiWorkData.baudrate = twiConfig(work);
    if (twiWorkData.baudrate <= 0)
    {
        radMsgLog (PRI_HIGH, "TWI: twiProtocolInit: autobaud failed!");
        return ERROR;
    }

    radMsgLog (PRI_STATUS, "TWI: autobaud = %d", twiWorkData.baudrate);

    // Reconfigure the serial port here to ensure consistency:
    serialPortConfig(work->medium.fd);
    tcflush (work->medium.fd, TCIFLUSH);
    tcflush (work->medium.fd, TCOFLUSH);

    if (!strcmp (work->stationInterface, "serial"))
    {
        radMsgLog (PRI_STATUS, "TWI on %s opened ...",
                   work->stationDevice);
    }
    else if (!strcmp (work->stationInterface, "ethernet"))
    {
        radMsgLog (PRI_STATUS, "TWI on %s:%d opened ...",
                   work->stationHost, work->stationPort);
    }

    // grab the station configuration now
    if (stationGetConfigValueInt (work,
                                  STATION_PARM_ELEVATION,
                                  &twiWorkData.elevation)
            == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: stationGetConfigValueInt ELEV failed!");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }
    if (stationGetConfigValueFloat (work,
                                    STATION_PARM_LATITUDE,
                                    &twiWorkData.latitude)
            == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: stationGetConfigValueInt LAT failed!");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }
    if (stationGetConfigValueFloat (work,
                                    STATION_PARM_LONGITUDE,
                                    &twiWorkData.longitude)
            == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: stationGetConfigValueInt LONG failed!");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }
    if (stationGetConfigValueInt (work,
                                  STATION_PARM_ARC_INTERVAL,
                                  &twiWorkData.archiveInterval)
            == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: stationGetConfigValueInt ARCINT failed!");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }

    // set the work archive interval now
    work->archiveInterval = twiWorkData.archiveInterval;

    // sanity check the archive interval against the most recent record
    if (stationVerifyArchiveInterval (work) == ERROR)
    {
        // bad magic!
        radMsgLog (PRI_HIGH, "stationInit: stationVerifyArchiveInterval failed!");
        radMsgLog (PRI_HIGH, "You must either move old archive data out of the way -or-");
        radMsgLog (PRI_HIGH, "fix the interval setting...");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }
    else
    {
        radMsgLog (PRI_STATUS, "station archive interval: %d minutes",
                   work->archiveInterval);
    }

    twiWorkData.totalRain = 0;

   // Create the rain accumulator (TWI_RAIN_RATE_PERIOD minute age)
    // so we can compute rain rate:
    twiWorkData.rainRateAccumulator = sensorAccumInit(TWI_RAIN_RATE_PERIOD);

    // Populate the accumulator with the last TWI_RAIN_RATE_PERIOD minutes:
    nowTime = time(NULL) - (WV_SECONDS_IN_HOUR/(60/TWI_RAIN_RATE_PERIOD));
    while ((nowTime = dbsqliteArchiveGetNextRecord(nowTime, &recordStore)) != ERROR)
    {
        sensorAccumAddSample(twiWorkData.rainRateAccumulator,
                             recordStore.dateTime,
                             recordStore.value[DATA_INDEX_rain]);
    }

    radMsgLog (PRI_STATUS, "Starting station interface: TWI"); 

    // initialize the station interface
    if (twiProtocolInit(work) == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: twiProtocolInit failed!");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }

    // do the initial GetReadings now
    if (twiProtocolGetReadings(work, &twiWorkData.twiReadings) != OK)
    {
        radMsgLog (PRI_HIGH, "stationInit: initial twiProtocolGetReadings failed!");
        twiProtocolExit (work);
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }


    // Initialize the 12-hour temp accumulator:
    twi12HourTempAvg = sensorAccumInit(60 * 12);

    // Load data for the last 12 hours:
    nowTime = time(NULL) - (WV_SECONDS_IN_HOUR * 12);
    while ((nowTime = dbsqliteArchiveGetNextRecord(nowTime, &recordStore)) != ERROR)
    {
        sensorAccumAddSample(twi12HourTempAvg, 
                             recordStore.dateTime, 
                             recordStore.value[DATA_INDEX_outTemp]);
    }

    // populate the LOOP structure
    storeLoopPkt (work, &work->loopPkt, &twiWorkData.twiReadings);

    // we must indicate successful completion here -
    // even though we are synchronous, the daemon wants to see this event
    radProcessEventsSend(NULL, STATION_INIT_COMPLETE_EVENT, 0);

    return OK;
}
示例#8
0
// station-supplied init function
// -- Can Be Asynchronous - event indication required --
//
// MUST:
//   - set the 'stationGeneratesArchives' flag in WVIEWD_WORK:
//     if the station generates archive records (TRUE) or they should be 
//     generated automatically by the daemon from the sensor readings (FALSE)
//   - Initialize the 'stationData' store for station work area
//   - Initialize the interface medium
//   - do initial LOOP acquisition
//   - do any catch-up on archive records if there is a data logger
//   - 'work->runningFlag' can be used for start up synchronization but should 
//     not be modified by the station interface code
//   - indicate init is done by sending the STATION_INIT_COMPLETE_EVENT event to
//     this process (radProcessEventsSend (NULL, STATION_INIT_COMPLETE_EVENT, 0))
//
// OPTIONAL:
//   - Initialize a state machine or any other construct required for the 
//     station interface - these should be stored in the 'stationData' store
//
// 'archiveIndication' - indication callback used to pass back an archive record
//   generated as a result of 'stationGetArchive' being called; should receive a
//   NULL pointer for 'newRecord' if no record available; only used if 
//   'stationGeneratesArchives' flag is set to TRUE by the station interface
//
// Returns: OK or ERROR
//
int stationInit
(
    WVIEWD_WORK     *work,
    void            (*archiveIndication)(ARCHIVE_PKT* newRecord)
)
{
    int             minutes;

    memset (&simWorkData, 0, sizeof(simWorkData));

    // save the archive indication callback (we should never need it)
    ArchiveIndicator = archiveIndication;

    // set our work data pointer
    work->stationData = &simWorkData;

    // set the Archive Generation flag to indicate the Simulator DOES NOT 
    // generate them
    work->stationGeneratesArchives = FALSE;

    // initialize the medium abstraction based on user configuration
    // we won't really open a serial channel...
    work->medium.type = MEDIUM_TYPE_NONE;

    // grab the station configuration now
    if (stationGetConfigValueInt (work, 
                                  STATION_PARM_ELEVATION, 
                                  &simWorkData.elevation) 
        == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: stationGetConfigValueInt ELEV failed!");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }
    if (stationGetConfigValueFloat (work, 
                                    STATION_PARM_LATITUDE, 
                                    &simWorkData.latitude) 
        == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: stationGetConfigValueInt LAT failed!");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }
    if (stationGetConfigValueFloat (work, 
                                    STATION_PARM_LONGITUDE, 
                                    &simWorkData.longitude) 
        == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: stationGetConfigValueInt LONG failed!");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }
    if (stationGetConfigValueInt (work, 
                                  STATION_PARM_ARC_INTERVAL, 
                                  &simWorkData.archiveInterval) 
        == ERROR)
    {
        radMsgLog (PRI_HIGH, "stationInit: stationGetConfigValueInt ARCINT failed!");
        (*(work->medium.exit)) (&work->medium);
        return ERROR;
    }

    // set the work archive interval now
    work->archiveInterval = simWorkData.archiveInterval;

    // sanity check the archive interval against the most recent record
    if (stationVerifyArchiveInterval (work) == ERROR)
    {
        // bad magic!
        radMsgLog (PRI_HIGH, "stationInit: stationVerifyArchiveInterval failed!");
        radMsgLog (PRI_HIGH, "You must either move old archive data out of the way -or-");
        radMsgLog (PRI_HIGH, "fix the interval setting...");
        return ERROR;
    }
    else
    {
        radMsgLog (PRI_STATUS, "station archive interval: %d minutes",
                   work->archiveInterval);
    }


    // initialize the station interface
    // nothing to do here...
    radMsgLog (PRI_STATUS, "Starting station interface: Simulator"); 


    // do the initial GetReadings now
    // populate the LOOP structure
    storeLoopPkt (work, &work->loopPkt);

    // compute the data generation period
    minutes = 360 * PERIOD_FACTOR;
    minutes *= (work->cdataInterval/1000);
    minutes /= 60;

    radMsgLog (PRI_STATUS, "Simulator station opened: %d minute data generation period...",
               minutes);

    // we can indicate successful completion here!
    radProcessEventsSend (NULL, STATION_INIT_COMPLETE_EVENT, 0);

    return OK;
}
示例#9
0
int wh1080Init (WVIEWD_WORK *work)
{
    WH1080_IF_DATA*     ifWorkData = (WH1080_IF_DATA*)work->stationData;
    fd_set              rfds;
    struct timeval      tv;
    int                 ret;
    time_t              nowTime = time(NULL) - (WV_SECONDS_IN_HOUR/(60/WH1080_RAIN_RATE_PERIOD));
    ARCHIVE_PKT         recordStore;
    unsigned char       controlBlock[WH1080_BUFFER_CHUNK];

    memset (&wh1080Work, 0, sizeof(wh1080Work));

    // Create the rain accumulator (WH1080_RAIN_RATE_PERIOD minute age)
    // so we can compute rain rate:
    ifWorkData->rainRateAccumulator = sensorAccumInit(WH1080_RAIN_RATE_PERIOD);

    // Populate the accumulator with the last WH1080_RAIN_RATE_PERIOD minutes:
    while ((nowTime = dbsqliteArchiveGetNextRecord(nowTime, &recordStore)) != ERROR)
    {
        sensorAccumAddSample(ifWorkData->rainRateAccumulator,
                             recordStore.dateTime,
                             recordStore.value[DATA_INDEX_rain]);
    }

    if ((*(work->medium.usbhidInit))(&work->medium) != OK)
    {
        return ERROR;
    }

    // Set the station to log data once per minute:
    while ((!work->exiting) && (readFixedBlock(work, controlBlock) != OK))
    {
        radMsgLog (PRI_HIGH, "WH1080: Initial fixed block read failed");
        (*(work->medium.usbhidExit))(&work->medium);
        radUtilsSleep(5000);
        (*(work->medium.usbhidInit))(&work->medium);
        radMsgLog (PRI_HIGH, "WH1080: Retrying initial fixed block read");
    }

    // For some reason the WH1080 wants the IF closed between a read and a write:
    (*(work->medium.usbhidExit))(&work->medium);
    if (work->exiting)
    {
        return ERROR;
    }

    controlBlock[WH1080_SAMPLING_INTERVAL] = 1;
    (*(work->medium.usbhidInit))(&work->medium);

    if (writeFixedBlock(work, controlBlock) == ERROR)
    {
        (*(work->medium.usbhidExit))(&work->medium);
        return ERROR;
    }

    radUtilsSleep(2000);

    (*(work->medium.usbhidExit))(&work->medium);

    radUtilsSleep(1000);

    wh1080Work.lastRecord = -1;

    // populate the LOOP structure:
    radMsgLog (PRI_HIGH, "Waiting for the next weather record to be ready "
                         "in the console to populate initial wview sensor readings "
                         "(this could take some time);");
    radMsgLog (PRI_HIGH, "While waiting be sure you are receiving all sensors on the console;");
    radMsgLog (PRI_HIGH, "if not, you may need to relocate the sensors or the console.");
    while ((!work->exiting) && (readStationData(work) != OK))
    {
        radUtilsSleep(1000);
    }
    if (work->exiting)
    {
        return ERROR;
    }

    ifWorkData->wh1080Readings = wh1080Work.sensorData;
    storeLoopPkt (work, &work->loopPkt, &ifWorkData->wh1080Readings);

    // we must indicate successful completion here -
    // even though we are synchronous, the daemon wants to see this event:
    radProcessEventsSend (NULL, STATION_INIT_COMPLETE_EVENT, 0);

    return OK;
}