dwChannelDrainerTemplate.hpp

Go to the documentation of this file.

 
// This code contains NVIDIA Confidential Information and is disclosed
// under the Mutual Non-Disclosure Agreement.
//
// Notice
// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES
// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
//
// NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. No third party distribution is allowed unless
// expressly authorized by NVIDIA.  Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2020-2022 NVIDIA Corporation. All rights reserved.
//
// NVIDIA Corporation and its licensors retain all intellectual property and proprietary
// rights in and to this software and related documentation and any modifications thereto.
// Any use, reproduction, disclosure or distribution of this software and related
// documentation without an express license agreement from NVIDIA Corporation is
// strictly prohibited.
//
#ifndef DWFRAMEWORK_DWNODES_SENSORS_DWSENSORNODE_DWCHANNELDRAINERTEMPLATE_HPP_
#define DWFRAMEWORK_DWNODES_SENSORS_DWSENSORNODE_DWCHANNELDRAINERTEMPLATE_HPP_
 
#include <dwframework/dwnodes/common/channelpackets/Codec.hpp>
#include <dwframework/dwnodes/common/channelpackets/EgomotionState.hpp>
#include <dwframework/dwnodes/common/channelpackets/FeatureList.hpp>
#include <dwframework/dwnodes/common/channelpackets/Image.hpp>
#include <dwframework/dwnodes/common/channelpackets/Lidar.hpp>
#include <dwframework/dwnodes/common/channelpackets/PointCloud.hpp>
#include <dwframework/dwnodes/common/channelpackets/Pyramid.hpp>
#include <dwframework/dwnodes/common/channelpackets/Radar.hpp>
#include <dwframework/dwnodes/common/channelpackets/SensorCommonTypes.hpp>
#include <dwframework/dwnodes/common/channelpackets/Sensors.hpp>
#include "dwSensorDrainerTemplate.hpp"
#include <dw/core/base/Types.h>
#include <dw/sensors/Sensors.h>
#include <dw/sensors/canbus/CAN.h>
#include <dw/sensors/radar/Radar.h>
#include <dwcgf/Exception.hpp>
#include <dwcgf/node/Node.hpp>
#include <dwcgf/port/Port.hpp>
#include <memory>
#include <unistd.h>
 
namespace dw
{
namespace framework
{
 
template <typename OutputProcessedDataType, typename InputProcessedDataType = OutputProcessedDataType>
struct ReadProcessedDataFromChannel
{
    using InputDataPort                                     = PortInput<InputProcessedDataType>*;
    std::shared_ptr<InputProcessedDataType> m_nextDataEvent = nullptr;
 
    virtual dwStatus readNextData(dwTime_t inTimeout_us, InputDataPort inputPort)
    {
 
        if (!inputPort->isBound())
        {
            return DW_NOT_AVAILABLE;
        }
 
        if (inputPort->wait(inTimeout_us) == DW_SUCCESS)
        {
            m_nextDataEvent = inputPort->recv();
            return DW_SUCCESS;
        }
 
        return DW_TIME_OUT;
    }
 
    virtual dwStatus getNextDataTimestamp(dwTime_t& outTimestamp) = 0;
 
    virtual dwStatus getNextData(OutputProcessedDataType* outDataFrame, InputDataPort) = 0;
 
    dwStatus reset()
    {
        m_nextDataEvent = nullptr;
        return DW_SUCCESS;
    }
};
 
template <typename OutputProcessedDataType, typename ReadProcessedDataFunc, typename InputProcessedDataType = OutputProcessedDataType>
class dwChannelDrainerTemplate : public dwBaseDrainerTemplate<OutputProcessedDataType, ReadProcessedDataFunc, PortInput<InputProcessedDataType>*>
{
    using InputDataPort = PortInput<InputProcessedDataType>*;
 
public:
    static constexpr char LOG_TAG[] = "dwChannelDrainerTemplate";
 
    explicit dwChannelDrainerTemplate(dwSensorDrainerParams params, std::unique_ptr<ReadProcessedDataFunc> readProcessedDataFunc, InputDataPort inputPort)
        : dwBaseDrainerTemplate<OutputProcessedDataType, ReadProcessedDataFunc, InputDataPort>(params, std::move(readProcessedDataFunc), inputPort)
    {
    }
 
    virtual ~dwChannelDrainerTemplate() = default;
 
    virtual dwStatus reset() override
    {
        this->m_virtualSyncTime = 0;
        this->m_nextDataReady   = false;
        return DW_SUCCESS;
    }
 
    // [out] outFrame output sensor frame
    // [in/out] latestTimestamp timestamp associated with the sensor frame
    // [in] timeout sensor reading timeout in microseconds
    // [in] isDroppingData indicates if data is being dropped
    dwStatus readProcessedData(OutputProcessedDataType* outFrame,
                               dwTime_t& latestTimestamp,
                               dwTime_t timeout,
                               bool isDroppingData = false) override
    {
        return dwBaseDrainerTemplate<OutputProcessedDataType, ReadProcessedDataFunc, InputDataPort>::tryRead(outFrame, latestTimestamp, timeout, isDroppingData);
    }
};
 
template <typename OutputProcessedDataType, typename ReadProcessedDataFunc, typename InputProcessedDataType>
constexpr char dwChannelDrainerTemplate<OutputProcessedDataType, ReadProcessedDataFunc, InputProcessedDataType>::LOG_TAG[];
} // namespace framework
} // namespace dw
 
#endif // DWFRAMEWORK_DWNODES_SENSORS_DWSENSORNODE_DWCHANNELDRAINERTEMPLATE_HPP_