mcp3x0x.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 MCP3X0X_HH
#define MCP3X0X_HH
 
#include "../spi.h"
#include "../time.h"
#include "../types_traits.h"
#include "../utilities.h"
 
namespace devices
{
    namespace mcp3x0x
    {
    }
}
 
namespace devices::mcp3x0x
{
    template<board::DigitalPin CS, typename CHANNEL_, uint16_t MASK, uint8_t RSHIFT, typename TYPE_ = uint16_t>
    class MCP3x0x : public spi::SPIDevice<
        CS, spi::ChipSelect::ACTIVE_LOW, spi::compute_clockrate(3'600'000UL), 
        spi::Mode::MODE_0, spi::DataOrder::MSB_FIRST>
    {
        using TRAIT = types_traits::Type_trait<TYPE_>;
        static_assert(TRAIT::IS_INT && (TRAIT::SIZE == sizeof(uint16_t)), "TYPE must be uint16_t or int16_t");
        static constexpr const bool IS_SIGNED = TRAIT::IS_SIGNED;
        static constexpr const uint16_t SIGN_MASK = ((MASK >> RSHIFT) + 1) >> 1;
        static constexpr const uint16_t NEGATIVE = 0xFFFF & ~(MASK >> RSHIFT);
 
    public:
        using CHANNEL = CHANNEL_;
 
        using TYPE = TYPE_;
 
        MCP3x0x() = default;
 
        TYPE read_channel(CHANNEL channel)
        {
            uint8_t result1;
            uint8_t result2;
            this->start_transfer();
            if (sizeof(CHANNEL) == sizeof(uint16_t))
            {
                this->transfer(utils::high_byte(uint16_t(channel)));
                result1 = this->transfer(utils::low_byte(uint16_t(channel)));
            }
            else
                result1 = this->transfer(uint8_t(channel));
            result2 = this->transfer(0x00);
            this->end_transfer();
            // Convert bytes pair to N-bits result
            uint16_t value = (utils::as_uint16_t(result1, result2) & MASK) >> RSHIFT;
            if (IS_SIGNED)
            {
                if (value & SIGN_MASK)
                    // value is negative, change it to negative int16_t
                    return TYPE(NEGATIVE | value);
                else
                    // value is positive, directly cast it to int16_t
                    return TYPE(value);
            }
            else
                return value;
        }
    };
}
 
#endif /* MCP3X0X_HH */