scom_utils.c

Go to the documentation of this file.

#define HAL_LOG_CHANNEL SCOM
#define HAL_LOG_SUBCHANNEL UTIL

#include "hal.h"
#include "scom.h"
#include "scom_filtering.h"
#include "scom_frame_type_filter.h"
#include <string.h>


// -----------------------------------------------------------------------------
//  SCOM_GetIdentity
// -----------------------------------------------------------------------------
SCOMResult SCOM_GetIdentity(SCOMDataLinkDesc* const scom, SCOMIdentity* const identity) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                HAL_ASSERT_AND_EXECUTE(identity != NULL) {
                        SCOMResult result = SCOM_ERROR;
                        memset(identity, 0x00, sizeof(SCOMIdentity)); // Clear the identity struct
                        // initialize the frame-match filter
                        SCOMFrameTypeMatchFilter filter;
                        if (SCOM_RESULT_OK == SCOM_InitializeFrameTypeMatchFilter(&filter, identity, sizeof(SCOMIdentity))) {
                                // set-up the filter to catch the IDENTIFY response
                                if (SCOM_RESULT_OK == SCOM_SetupFrameTypeMatchFilter(&filter, SCOM_FRAMETYPE_IDENTIFY)) {
                                        // insert filter into SCOM
                                        if(SCOM_RESULT_OK == SCOM_InsertFilter(scom, &filter.filter)) {
                                                // send the IDENTIFY request
                                                if (SCOM_RESULT_OK == SCOM_SendFrame(scom, 1, SCOM_FRAMETYPE_IDENTIFY, NULL, 0)) {
                                                        // frame stored successfully, now we must wait for the response
                                                        result = (SCOM_RESULT_OK == SCOM_WaitForFrameTypeFilter(&filter, 3000)) ? SCOM_RESULT_OK : SCOM_COMMUNICATION_ERROR;
                                                } else {
                                                        // unable to send identify request
                                                        result = SCOM_TX_FRAME_BUFFER_OVERRUN;
                                                }
                                                SCOM_RemoveFilter(scom, &filter.filter); // remove the filter
                                        } else {
                                                result = SCOM_FILTER_ERROR;
                                        }
                                } else {
                                        result = SCOM_FILTER_LIST_FULL;
                                }
                                SCOM_DeinitializeFrameTypeMatchFilter(&filter); // deinitialize the filter
                        } else {
                                result = SCOM_FILTER_ERROR;
                        }
                        return result;
                }
        }
        return SCOM_RESULT_ERROR;
} /* SCOM_GetIdentity */


// -----------------------------------------------------------------------------
//  SCOM_WaitForDevice
// -----------------------------------------------------------------------------
SCOMResult SCOM_WaitForDevice(SCOMDataLink scom, uint32_t expectedDeviceClass, uint32_t expectedDeviceClassMask, uint32_t probeInterval, uint32_t timeout, SCOMIdentity* identity) {
        SCOMIdentity tempIdentity;
        SCOMFrameTypeMatchFilter filter;
        SCOMResult result = SCOM_ERROR;
        uint32_t startTime;
        bool found = false;

        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                // clear the identity struct
                memset(&tempIdentity, 0x00, sizeof(SCOMIdentity));

                // initialize the frame-match filter
                if (SCOM_RESULT_OK == SCOM_InitializeFrameTypeMatchFilter(&filter, &tempIdentity, sizeof(SCOMIdentity))) {
                        // set-up the filter to catch the IDENTIFY response
                        if (SCOM_RESULT_OK == SCOM_SetupFrameTypeMatchFilter(&filter, SCOM_FRAMETYPE_IDENTIFY)) {
                                // insert filter into SCOM
                                if(SCOM_RESULT_OK == SCOM_InsertFilter(scom, &filter.filter)) {
                                        // mark start time
                                        startTime = scom->clockSource();

                                        while ((!found) && (scom->clockSource() < startTime + timeout)) {
                                                // send the IDENTIFY request
                                                HAL_LOG_INFO("SCOM_WaitForDevice: Sending identify request with no ACK");
                                                if (SCOM_RESULT_OK == SCOM_SendFrameWithoutAck(scom, 1, SCOM_FRAMETYPE_IDENTIFY, NULL, 0)) {
                                                        // frame stored successfully, now we must wait for the response
                                                        if (SCOM_RESULT_OK == SCOM_WaitForFrameTypeFilter(&filter, probeInterval)) {
                                                                // got response
                                                                if ((tempIdentity.deviceClass & expectedDeviceClassMask) == (expectedDeviceClass & expectedDeviceClassMask)) {
                                                                        // device class matches
                                                                        HAL_LOG_INFO("SCOM_WaitForDevice: Got matching response: DeviceClass=0x%" PRIX32);
                                                                        if (identity) {
                                                                                memcpy(identity, &tempIdentity, sizeof(SCOMIdentity));
                                                                        }
                                                                        found = true;
                                                                        result = SCOM_RESULT_OK;
                                                                } else {
                                                                        HAL_LOG_WARNING("SCOM_WaitForDevice: Got non-matching response. Will try again");
                                                                }
                                                        } else {
                                                                HAL_LOG_WARNING("SCOM_WaitForDevice: Got no response. Will try again");
                                                                result = SCOM_NO_DEVICE;
                                                        }
                                                }
                                        }
                                        // remove the filter
                                        SCOM_RemoveFilter(scom, &filter.filter);
                                } else {
                                        // unable to set-up frame match filter
                                        result = SCOM_FILTER_ERROR;
                                }
                        } else {
                                // unable to insert filter
                                result = SCOM_FILTER_LIST_FULL;
                        }
                        // deinitialize the filter
                        SCOM_DeinitializeFrameTypeMatchFilter(&filter);
                } else {
                        // unable to initialize the frame-match filter
                        result = SCOM_FILTER_ERROR;
                }
        }

        return result;

} /* SCOM_WaitForDevice */


// -----------------------------------------------------------------------------
//  SCOM_ScanAndRun
// -----------------------------------------------------------------------------
unsigned int SCOM_ScanAndRun(void (*initProc)(IODevice iodevice, const char* deviceName),
                bool (*userProc)(SCOMDataLink scom, SCOMIdentity* identity, const char* deviceName),
                uint32_t responseTimeout)
{
        unsigned int deviceCount, deviceNo, validDeviceCounter;
        IODevice iodev;
        SCOMDataLink scom;
        SCOMFrameBuffer* frameBuffer;
        SCOMIdentity identity;

        // used to count SCOM valid devices found
        validDeviceCounter = 0;

        // enumerate all serial ports
        deviceCount = IOSERIAL_Enumerate();

        // for each serial port found
        for (deviceNo = 0; deviceNo < deviceCount; deviceNo++) {

                // create IODevice (actually IOSerialDevice)
                iodev = IOSERIAL_Create(IOSERIAL_GetEnumeratedDeviceName(deviceNo));
                if (iodev) {

                        // initialize the IODevice
                        if (HALRESULT_OK == IODEV_Init(iodev)) {
                                IOSERIAL_SetBaudrate(iodev, 115200);
                                HAL_LOG_INFO("ScanAndRun working on %s", IOSERIAL_GetEnumeratedDeviceName(deviceNo));

                                IODEV_EnableWrite(iodev);
                                IODEV_EnableRead(iodev);

                                // call user initialization proc
                                if (initProc) {
                                        initProc(iodev, IOSERIAL_GetEnumeratedDeviceName(deviceNo));
                                }


                                // create SCOM object
                                scom = SCOM_Create();
                                if (scom) {
                                        // create SCOM frame buffer
                                        frameBuffer = SCOM_CreateFrameBuffer(16, 16);

                                        // initialize SCOM
                                        SCOM_Init(scom, iodev, frameBuffer, OS_GetSystemTime, 1000, 0, 0, 0, NULL);
                                        SCOM_InitFiltering(scom);
                                        // run SCOM threads
                                        SCOM_RunProcessingThread(scom);
                                        SCOM_RunFilteringThread(scom);
                                        // try to identify the remote SCOM device
                                        if (SCOM_RESULT_OK == SCOM_WaitForDevice(scom, 0, 0, 1000, responseTimeout, &identity)) {
                                                // identity was retrieved successfully, this is a valid SCOM device
                                                if (userProc) {
                                                        // run the user function
                                                        if (userProc(scom, &identity, IOSERIAL_GetEnumeratedDeviceName(deviceNo))) {
                                                                // if user function returns true, we count this device as valid
                                                                validDeviceCounter++;
                                                        }
                                                } else {
                                                        // the user function was not provided, we count this device as valid anyway
                                                        validDeviceCounter++;
                                                }
                                        }
                                        // deinitialize SCOM
                                        SCOM_StopFilteringThread(scom);
                                        SCOM_StopProcessingThread(scom);
                                        SCOM_DeinitFiltering(scom);
                                        SCOM_Deinit(scom);
                                        // destroy SCOM object
                                        SCOM_Destroy(scom);
                                }
                                // deinitialize the IODevice
                                IODEV_Deinit(iodev);
                        }
                        // destroy the IODevice
                        IOSERIAL_Destroy(iodev);
                }
        }

        return validDeviceCounter;
} /* SCOM_ScanAndRun */