isobus_diagnostic_protocol.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
 
#ifndef ISOBUS_DIAGNOSTIC_PROTOCOL_HPP
#define ISOBUS_DIAGNOSTIC_PROTOCOL_HPP
 
#include "isobus/isobus/can_internal_control_function.hpp"
#include "isobus/isobus/isobus_functionalities.hpp"
#include "isobus/utility/processing_flags.hpp"
 
#include <array>
#include <list>
#include <memory>
#include <string>
 
namespace isobus
{
    //================================================================================================
    //================================================================================================
    class DiagnosticProtocol
    {
    public:
        enum class ECUIdentificationFields : std::uint8_t
        {
            PartNumber = 0, 
            SerialNumber, 
            Location, 
            Type, 
            ManufacturerName, 
            HardwareID, 
            NumberOfFields 
        };
 
        enum class LampStatus
        {
            None,
            MalfunctionIndicatorLampSolid, 
            MalfunctionIndicatorLampSlowFlash, 
            MalfunctionIndicatorLampFastFlash, 
            RedStopLampSolid, 
            RedStopLampSlowFlash, 
            RedStopLampFastFlash, 
            AmberWarningLampSolid, 
            AmberWarningLampSlowFlash, 
            AmberWarningLampFastFlash, 
            EngineProtectLampSolid, 
            EngineProtectLampSlowFlash, 
            EngineProtectLampFastFlash 
        };
 
        enum class FailureModeIdentifier
        {
            DataValidAboveNormalMostSevere = 0, 
            DataValidBelowNormalMostSevere = 1, 
            DataErratic = 2, 
            VoltageAboveNormal = 3, 
            VoltageBelowNormal = 4, 
            CurrentBelowNormal = 5, 
            CurrentAboveNormal = 6, 
            MechanicalSystemNotResponding = 7, 
            AbnormalFrequency = 8, 
            AbnormalUpdateRate = 9, 
            AbnormalRateOfChange = 10, 
            RootCauseNotKnown = 11, 
            BadIntelligentDevice = 12, 
            OutOfCalibration = 13, 
            SpecialInstructions = 14, 
            DataValidAboveNormalLeastSevere = 15, 
            DataValidAboveNormalModeratelySevere = 16, 
            DataValidBelowNormalLeastSevere = 17, 
            DataValidBelowNormalModeratelySevere = 18, 
            ReceivedNetworkDataInError = 19, 
            ConditionExists = 31 
        };
 
        enum class TransmitFlags
        {
            DM1 = 0, 
            DM2, 
            DiagnosticProtocolID, 
            ProductIdentification, 
            DM22, 
            ECUIdentification, 
            SoftwareIdentification, 
 
            NumberOfFlags 
        };
 
        enum class NetworkType : std::uint8_t
        {
            SAEJ1939Network1PrimaryVehicleNetwork = 0,
            SAEJ1922Network = 1,
            SAEJ1587Network = 2,
            CurrentDataLink = 3,
            OtherManufacturerSpecifiedPort = 4,
            SAEJ1850Network = 5,
            ISO9141Network = 6,
            SAEJ1939Network2 = 7,
            SAEJ1939Network4 = 8,
            ProprietaryNetwork2 = 9,
            ProprietaryNetwork1 = 10,
            SAEJ1939Network3 = 11,
            SAEJ1939Network5 = 25,
            SAEJ1939Network6 = 26,
            SAEJ1939Network7 = 27,
            SAEJ1939Network8 = 28,
            SAEJ1939Network11 = 29,
            SAEJ1939Network10 = 30,
            SAEJ1939Network9 = 31,
            Reserved = 32
        };
 
        enum class StopStartCommand : std::uint8_t
        {
            StopBroadcast = 0, 
            StartBroadcast = 1, 
            Reserved = 2, 
            DontCareNoAction = 3 
        };
 
        enum class SuspendSignalState : std::uint8_t
        {
            IndefiniteSuspension = 0, 
            PartialIndefiniteSuspension = 1, 
            TemporarySuspension = 2, 
            PartialTemporarySuspension = 3, 
            Resuming = 4, 
            NotAvailable = 15 
        };
 
        //================================================================================================
        //================================================================================================
        class DiagnosticTroubleCode
        {
        public:
            DiagnosticTroubleCode() = default;
 
            DiagnosticTroubleCode(std::uint32_t spn, FailureModeIdentifier fmi, LampStatus lamp);
 
            bool operator==(const DiagnosticTroubleCode &obj) const;
 
            std::uint8_t get_occurrence_count() const;
 
            std::uint32_t get_suspect_parameter_number() const;
 
            FailureModeIdentifier get_failure_mode_identifier() const;
 
        private:
            friend class DiagnosticProtocol; 
            std::uint32_t suspectParameterNumber = 0xFFFFFFFF; 
            FailureModeIdentifier failureModeIdentifier = FailureModeIdentifier::ConditionExists; 
            LampStatus lampState = LampStatus::None; 
            std::uint8_t occurrenceCount = 0; 
        };
 
        DiagnosticProtocol(std::shared_ptr<InternalControlFunction> internalControlFunction,
                           NetworkType networkType = NetworkType::ProprietaryNetwork1);
 
        ~DiagnosticProtocol();
 
        bool initialize();
 
        bool get_initialized() const;
 
        void terminate();
 
        void update();
 
        void set_j1939_mode(bool value);
 
        bool get_j1939_mode() const;
 
        ControlFunctionFunctionalities ControlFunctionFunctionalitiesMessageInterface;
 
        void clear_active_diagnostic_trouble_codes();
 
        void clear_inactive_diagnostic_trouble_codes();
 
        void clear_software_id_fields();
 
        void set_ecu_id_field(ECUIdentificationFields field, const std::string &value);
 
        bool set_diagnostic_trouble_code_active(const DiagnosticTroubleCode &dtc, bool active);
 
        bool get_diagnostic_trouble_code_active(const DiagnosticTroubleCode &dtc);
 
        bool set_product_identification_code(const std::string &value);
 
        bool set_product_identification_brand(const std::string &value);
 
        bool set_product_identification_model(const std::string &value);
 
        void set_software_id_field(std::uint32_t index, const std::string &value);
 
        bool suspend_broadcasts(std::uint16_t suspendTime_seconds = 0xFFFF);
 
        bool get_broadcast_state() const;
 
    private:
        enum class Lamps
        {
            MalfunctionIndicatorLamp, 
            RedStopLamp, 
            AmberWarningLamp, 
            ProtectLamp 
        };
 
        enum class FlashState
        {
            Solid, 
            Slow, 
            Fast 
        };
 
        enum class DM22ControlByte : std::uint8_t
        {
            RequestToClearPreviouslyActiveDTC = 0x01, 
            PositiveAcknowledgeOfPreviouslyActiveDTCClear = 0x02, 
            NegativeAcknowledgeOfPreviouslyActiveDTCClear = 0x03, 
            RequestToClearActiveDTC = 0x11, 
            PositiveAcknowledgeOfActiveDTCClear = 0x12, 
            NegativeAcknowledgeOfActiveDTCClear = 0x13 
        };
 
        enum class DM22NegativeAcknowledgeIndicator : std::uint8_t
        {
            General = 0x00, 
            AccessDenied = 0x01, 
            UnknownOrDoesNotExist = 0x02, 
            DTCNoLongerPreviouslyActive = 0x03, 
            DTCNoLongerActive = 0x04 
        };
 
        struct DM22Data
        {
            std::shared_ptr<ControlFunction> destination; 
            std::uint32_t suspectParameterNumber; 
            std::uint8_t failureModeIdentifier; 
            std::uint8_t nackIndicator; 
            bool clearActive; 
            bool nack; 
        };
 
        static constexpr std::uint32_t DM_MAX_FREQUENCY_MS = 1000; 
        static constexpr std::uint32_t DM13_HOLD_SIGNAL_TRANSMIT_INTERVAL_MS = 5000; 
        static constexpr std::uint32_t DM13_TIMEOUT_MS = 6000; 
        static constexpr std::uint16_t MAX_PAYLOAD_SIZE_BYTES = 1785; 
        static constexpr std::uint16_t MAX_DM13_CUSTOM_SUSPEND_TIME_MS = 64255; 
        static constexpr std::uint8_t DM_PAYLOAD_BYTES_PER_DTC = 4; 
        static constexpr std::uint8_t PRODUCT_IDENTIFICATION_MAX_STRING_LENGTH = 50; 
        static constexpr std::uint8_t DM13_NUMBER_OF_J1939_NETWORKS = 11; 
        static constexpr std::uint8_t DM13_NETWORK_BITMASK = 0x03; 
        static constexpr std::uint8_t DM13_BITS_PER_NETWORK = 2; 
 
        std::uint8_t convert_flash_state_to_byte(FlashState flash) const;
 
        void get_active_list_lamp_state_and_flash_state(Lamps targetLamp, FlashState &flash, bool &lampOn) const;
 
        void get_inactive_list_lamp_state_and_flash_state(Lamps targetLamp, FlashState &flash, bool &lampOn) const;
 
        void on_address_violation(std::shared_ptr<InternalControlFunction> affectedControlFunction);
 
        bool send_diagnostic_message_1() const;
 
        bool send_diagnostic_message_2() const;
 
        bool send_diagnostic_protocol_identification() const;
 
        bool send_dm13_announce_suspension(std::uint16_t suspendTime_seconds) const;
 
        bool send_ecu_identification() const;
 
        bool send_product_identification() const;
 
        bool send_software_identification() const;
 
        bool process_all_dm22_responses();
 
        void process_message(const CANMessage &message);
 
        static void process_message(const CANMessage &message, void *parent);
 
        bool parse_j1939_network_states(const CANMessage &message);
 
        bool process_parameter_group_number_request(std::uint32_t parameterGroupNumber,
                                                    std::shared_ptr<ControlFunction> requestingControlFunction,
                                                    bool &acknowledge,
                                                    AcknowledgementType &acknowledgementType);
 
        // @brief Handles PGN requests for the diagnostic protocol
        static bool process_parameter_group_number_request(std::uint32_t parameterGroupNumber,
                                                           std::shared_ptr<ControlFunction> requestingControlFunction,
                                                           bool &acknowledge,
                                                           AcknowledgementType &acknowledgementType,
                                                           void *parentPointer);
 
        static void process_flags(std::uint32_t flag, void *parentPointer);
 
        std::shared_ptr<InternalControlFunction> myControlFunction; 
        EventCallbackHandle addressViolationEventHandle; 
        NetworkType networkType; 
        std::vector<DiagnosticTroubleCode> activeDTCList; 
        std::vector<DiagnosticTroubleCode> inactiveDTCList; 
        std::vector<DM22Data> dm22ResponseQueue; 
        std::vector<std::string> ecuIdentificationFields; 
        std::vector<std::string> softwareIdentificationFields; 
        ProcessingFlags txFlags; 
        std::string productIdentificationCode; 
        std::string productIdentificationBrand; 
        std::string productIdentificationModel; 
        std::uint32_t lastDM1SentTimestamp = 0; 
        std::uint32_t lastDM13ReceivedTimestamp = 0; 
        std::uint16_t customDM13SuspensionTime = 0; 
        bool broadcastState = true; 
        bool j1939Mode = false; 
        bool initialized = false; 
    };
}
 
#endif // ISOBUS_DIAGNOSTIC_PROTOCOL_HPP