i2c_status.h

Go to the documentation of this file.

//   Copyright 2016-2023 Jean-Francois Poilpret
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
 
 
#ifndef I2C_STATUS_HH
#define I2C_STATUS_HH
 
#include "flash.h"
#include "ios.h"
#include "i2c_handler_common.h"
 
namespace i2c
{
    namespace status
    {
    }
}
 
namespace i2c::status
{
    enum class STATUS : uint8_t
    {
        TRACE_ERROR = 0x01,
        TRACE_ALL = 0xFF
    };
 
    template<uint8_t SIZE> class I2CStatusRecorder
    {
    public:
        explicit I2CStatusRecorder(STATUS trace = STATUS::TRACE_ALL) : trace_{trace} {}
 
        void reset()
        {
            index_ = 0;
        }
 
        template<typename OSTREAM>
        void trace(OSTREAM& out, bool hex_status = true)
        {
            if (hex_status)
                for (uint8_t i = 0; i < index_; ++i)
                {
                    out.setf(streams::ios::hex, streams::ios::basefield);
                    out << uint8_t(expected_[i]) << ' ';
                    out.setf(streams::ios::hex, streams::ios::basefield);
                    out << uint8_t(actual_[i]) << '\n';
                }
            else
                for (uint8_t i = 0; i < index_; ++i)
                    out << expected_[i] << ' ' << actual_[i] << '\n';
            if (index_ >= SIZE)
                out << F("# OVF #") << '\n';
            index_ = 0;
        }
 
        void operator()(Status expected, Status actual)
        {
            if (index_ >= SIZE) return;
            if ((expected != actual) || (trace_ == STATUS::TRACE_ALL))
            {
                expected_[index_] = expected;
                actual_[index_++] = actual;
            }
        }
 
    private:
        Status expected_[SIZE];
        Status actual_[SIZE];
        uint8_t index_ = 0;
        STATUS trace_;
    };
 
    template<typename OSTREAM>
    class I2CStatusLiveLogger
    {
    public:
        I2CStatusLiveLogger(OSTREAM& out, STATUS trace = STATUS::TRACE_ALL, bool hex_status = true)
        : out_{out}, trace_{trace}, hex_status_{hex_status} {}
 
        void operator()(Status expected, Status actual)
        {
            if ((expected != actual) || (trace_ == STATUS::TRACE_ALL))
            {
                if (hex_status_)
                {
                    out_.setf(streams::ios::hex, streams::ios::basefield);
                    out_ << uint8_t(expected) << ' ';
                    out_.setf(streams::ios::hex, streams::ios::basefield);
                    out_ << uint8_t(actual) << '\n';
                }
                else
                    out_ << expected << ' ' << actual << '\n';
            }
        }
 
    private:
        OSTREAM& out_;
        STATUS trace_;
        bool hex_status_;
    };
 
    class I2CLatestStatusHolder
    {
    public:
        I2CLatestStatusHolder() = default;
 
        Status latest_status() const
        {
            return actual_;
        }
 
        Status latest_expected_status() const
        {
            return expected_;
        }
 
        void operator()(Status expected, Status actual)
        {
            expected_ = expected;
            actual_ = actual;
        }
 
    private:
        Status actual_ = Status::OK;
        Status expected_ = Status::OK;
    };
}
 
#endif /* I2C_STATUS_HH */