i2c_debug.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_DEBUG_HH
#define I2C_DEBUG_HH
 
#include "flash.h"
#include "i2c_handler_common.h"
#include "i2c_status.h"
 
namespace i2c
{
    namespace debug
    {
    }
}
 
namespace i2c::debug
{
    // Add utility ostream insert operator for FutureStatus
    template<typename OSTREAM> OSTREAM& operator<<(OSTREAM& out, i2c::DebugStatus status)
    {
        // Conversion lambda for local usage
        auto convert = [](i2c::DebugStatus s)
        {
            switch (s)
            {
                case i2c::DebugStatus::START:
                return F("ST ");
 
                case i2c::DebugStatus::REPEAT_START:
                return F("RS ");
 
                case i2c::DebugStatus::SLAW:
                return F("AW ");
 
                case i2c::DebugStatus::SLAR:
                return F("AR ");
 
                case i2c::DebugStatus::SEND:
                return F("S ");
 
                case i2c::DebugStatus::RECV:
                return F("R ");
 
                case i2c::DebugStatus::RECV_LAST:
                return F("RL ");
 
                case i2c::DebugStatus::STOP:
                return F("SP ");
 
                case i2c::DebugStatus::SEND_OK:
                return F("So ");
 
                case i2c::DebugStatus::SEND_ERROR:
                return F("Se ");
 
                case i2c::DebugStatus::RECV_OK:
                return F("Ro ");
 
                case i2c::DebugStatus::RECV_ERROR:
                return F("Re ");
 
                default:
                return F("");
            }
        };
        return out << convert(status);
    }
 
    enum class DEBUG : uint8_t
    {
        DEBUG_STEPS = 0x01,
        DEBUG_SEND_OK = 0x02,
        DEBUG_SEND_ERR = 0x04,
        DEBUG_RECV_OK = 0x08,
        DEBUG_RECV_ERR = 0x10,
        DEBUG_ALL = 0xFF
    };
 
    DEBUG operator|(DEBUG a, DEBUG b);
 
    template<uint8_t SIZE> class I2CDebugRecorder
    {
    public:
        explicit I2CDebugRecorder(DEBUG debug = DEBUG::DEBUG_ALL) : debug_{debug} {}
 
        void reset()
        {
            index_ = 0;
        }
 
        template<typename OSTREAM>
        void trace(OSTREAM& out)
        {
            for (uint8_t i = 0; i < index_; ++i)
            {
                const i2c::DebugStatus status = status_[i];
                switch (status)
                {
                    case i2c::DebugStatus::START:
                    case i2c::DebugStatus::REPEAT_START:
                    case i2c::DebugStatus::STOP:
                    case i2c::DebugStatus::RECV_ERROR:
                    case i2c::DebugStatus::RECV:
                    case i2c::DebugStatus::RECV_LAST:
                    case i2c::DebugStatus::SEND_ERROR:
                    case i2c::DebugStatus::SEND_OK:
                    out << status;
                    break;
 
                    default:
                    out << status;
                    out.setf(streams::ios::hex, streams::ios::basefield);
                    out << data_[i] << ' ';
                }
            }
            if (index_ >= SIZE)
                out << F("# OVF #");
            out << '\n';
            index_ = 0;
        }
 
        void operator()(i2c::DebugStatus status, uint8_t data)
        {
            if (index_ >= SIZE) return;
            switch (status)
            {
                case i2c::DebugStatus::START:
                case i2c::DebugStatus::REPEAT_START:
                case i2c::DebugStatus::STOP:
                case i2c::DebugStatus::SLAW:
                case i2c::DebugStatus::SLAR:
                case i2c::DebugStatus::SEND:
                case i2c::DebugStatus::RECV:
                case i2c::DebugStatus::RECV_LAST:
                if (uint8_t(debug_) & uint8_t(DEBUG::DEBUG_STEPS))
                {
                    status_[index_] = status;
                    data_[index_++] = data;
                }
                break;
 
                case i2c::DebugStatus::SEND_OK:
                if (uint8_t(debug_) & uint8_t(DEBUG::DEBUG_SEND_OK))
                {
                    status_[index_] = status;
                    data_[index_++] = data;
                }
                break;
 
                case i2c::DebugStatus::SEND_ERROR:
                if (uint8_t(debug_) & uint8_t(DEBUG::DEBUG_SEND_ERR))
                {
                    status_[index_] = status;
                    data_[index_++] = data;
                }
                break;
 
                case i2c::DebugStatus::RECV_OK:
                if (uint8_t(debug_) & uint8_t(DEBUG::DEBUG_RECV_OK))
                {
                    status_[index_] = status;
                    data_[index_++] = data;
                }
                break;
 
                case i2c::DebugStatus::RECV_ERROR:
                if (uint8_t(debug_) & uint8_t(DEBUG::DEBUG_RECV_ERR))
                {
                    status_[index_] = status;
                    data_[index_++] = data;
                }
                break;
            }
        }
 
    private:
        i2c::DebugStatus status_[SIZE];
        uint8_t data_[SIZE];
        uint8_t index_ = 0;
        DEBUG debug_;
    };
 
    template<typename OSTREAM>
    class I2CDebugLiveLogger
    {
    public:
        I2CDebugLiveLogger(OSTREAM& out, DEBUG debug = DEBUG::DEBUG_ALL) : out_{out}, debug_{debug} {}
 
        void operator()(i2c::DebugStatus status, uint8_t data)
        {
            bool display = false;
            switch (status)
            {
                case i2c::DebugStatus::START:
                case i2c::DebugStatus::REPEAT_START:
                case i2c::DebugStatus::STOP:
                case i2c::DebugStatus::SLAW:
                case i2c::DebugStatus::SLAR:
                case i2c::DebugStatus::SEND:
                case i2c::DebugStatus::RECV:
                case i2c::DebugStatus::RECV_LAST:
                display = (uint8_t(debug_) & uint8_t(DEBUG::DEBUG_STEPS));
                break;
 
                case i2c::DebugStatus::SEND_OK:
                display = (uint8_t(debug_) & uint8_t(DEBUG::DEBUG_SEND_OK));
                break;
 
                case i2c::DebugStatus::SEND_ERROR:
                display = (uint8_t(debug_) & uint8_t(DEBUG::DEBUG_SEND_ERR));
                break;
 
                case i2c::DebugStatus::RECV_OK:
                display = (uint8_t(debug_) & uint8_t(DEBUG::DEBUG_RECV_OK));
                break;
 
                case i2c::DebugStatus::RECV_ERROR:
                display = (uint8_t(debug_) & uint8_t(DEBUG::DEBUG_RECV_ERR));
                break;
            }
            if (display)
            {
                // Show data only if relevant
                switch (status)
                {
                    case i2c::DebugStatus::START:
                    case i2c::DebugStatus::REPEAT_START:
                    case i2c::DebugStatus::STOP:
                    case i2c::DebugStatus::RECV_ERROR:
                    case i2c::DebugStatus::RECV:
                    case i2c::DebugStatus::RECV_LAST:
                    case i2c::DebugStatus::SEND_ERROR:
                    case i2c::DebugStatus::SEND_OK:
                    out_ << status;
                    break;
 
                    default:
                    out_ << status;
                    out_.setf(streams::ios::hex, streams::ios::basefield);
                    out_ << data << ' ';
                }
            }
        }
 
    private:
        OSTREAM& out_;
        DEBUG debug_;
    };
 
    template<uint8_t SIZE_STATUS, uint8_t SIZE_DEBUG>
    class I2CDebugStatusRecorder : 
        public i2c::status::I2CStatusRecorder<SIZE_STATUS>, public I2CDebugRecorder<SIZE_DEBUG>
    {
    public:
        using I2CDebugRecorder<SIZE_DEBUG>::operator();
        using i2c::status::I2CStatusRecorder<SIZE_STATUS>::operator();
        
        I2CDebugStatusRecorder(
            i2c::status::STATUS trace = i2c::status::STATUS::TRACE_ALL, DEBUG debug = DEBUG::DEBUG_ALL)
        : i2c::status::I2CStatusRecorder<SIZE_STATUS>{trace}, I2CDebugRecorder<SIZE_DEBUG>{debug} {}
 
        void reset()
        {
            i2c::status::I2CStatusRecorder<SIZE_STATUS>::reset();
            I2CDebugRecorder<SIZE_DEBUG>::reset();
        }
 
        template<typename OSTREAM>
        void trace(OSTREAM& out, bool hex_status = true)
        {
            I2CDebugRecorder<SIZE_DEBUG>::trace(out);
            i2c::status::I2CStatusRecorder<SIZE_STATUS>::trace(out, hex_status);
        }
    };
 
    template<typename OSTREAM>
    class I2CDebugStatusLiveLogger : 
        public i2c::status::I2CStatusLiveLogger<OSTREAM>, public I2CDebugLiveLogger<OSTREAM>
    {
    public:
        using I2CDebugLiveLogger<OSTREAM>::operator();
        using i2c::status::I2CStatusLiveLogger<OSTREAM>::operator();
 
        I2CDebugStatusLiveLogger(OSTREAM& out,
            i2c::status::STATUS trace = i2c::status::STATUS::TRACE_ALL, 
            DEBUG debug = DEBUG::DEBUG_ALL,
            bool hex_status = true)
            :   i2c::status::I2CStatusLiveLogger<OSTREAM>{out, trace, hex_status},
                I2CDebugLiveLogger<OSTREAM>{out, debug} {}
    };
}
 
#endif /* I2C_DEBUG_HH */