mcp2515.hpp

/*
 * Author: Jon Trulson <jtrulson@ics.com>
 * Copyright (c) 2016 Intel Corporation.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#pragma once

#include <string>

#include "mcp2515.h"

namespace upm {

    class MCP2515 {
    public:

        MCP2515(int bus, int csPin);

        ~MCP2515();

        void reset();

        void setOpmode(MCP2515_OPMODE_T opmode);

        void setSpeed(MCP2515_SPEED_T speed);

        void loadTXBuffer(MCP2515_TX_BUFFER_T bufnum,
                          int id, bool ext, bool rtr,
                          std::string payload);

        void transmitBuffer(MCP2515_TX_BUFFER_T bufnum, bool wait);

        bool isTXBufferFree(MCP2515_TX_BUFFER_T bufnum);

        MCP2515_TX_BUFFER_T findFreeTXBuffer();

        void setTXBufferPriority(MCP2515_TX_BUFFER_T bufnum,
                                 MCP2515_TXP_T priority);

        void abortTX(MCP2515_TX_BUFFER_T bufnum);

        void setRXBufferMode(MCP2515_RX_BUFFER_T bufnum,
                             MCP2515_RXMODE_T rxm);

        MCP2515_RXMSG_T rxStatusMsgs();

        MCP2515_MSGTYPE_T rxStatusMsgType();

        MCP2515_FILTERMATCH_T rxStatusFiltermatch();

        upm_result_t getRXMsg(MCP2515_RX_BUFFER_T bufnum);

        void printMsg();


        int msgGetID()
        {
            return m_message.id;
        }

        bool msgGetRTR()
        {
            return m_message.rtr;
        }

        bool msgGetEXT()
        {
            return m_message.ext;
        }

        int msgGetFilterNum()
        {
            return m_message.filter_num;
        }

        int msgGetPayloadLen()
        {
            return m_message.len;
        }

        std::string msgGetPayload()
        {
            return std::string((char *)m_message.pkt.data, m_message.len);
        }


        void installISR(int pin, void (*isr)(void *), void *arg);


        void uninstallISR();

        void setIntrEnables(uint8_t enables);

        uint8_t getIntrFlags();

        void setIntrFlags(uint8_t flags);

        void clearIntrFlags(uint8_t flags);

        uint8_t getErrorFlags();

        void clearErrorFlags(uint8_t flags);

        void setFilter(MCP2515_RX_FILTER_T filter, bool ext, int id);

        void setMask(MCP2515_RX_MASK_T mask, bool ext, int id);


    protected:
        mcp2515_context m_mcp2515;

        // We operate only on this message (for received messages) to
        // simplify SWIG accesses.
        MCP2515_MSG_T m_message;

        std::string busRead(uint8_t cmd, std::string args, int datalen);

        void busWrite(uint8_t cmd, std::string data);

        void writeReg(uint8_t reg, uint8_t value);

        void writeRegs(uint8_t reg, std::string buffer);

        uint8_t readReg(uint8_t reg);

        void bitModify(uint8_t addr, uint8_t mask, uint8_t value);

    private:
        /* Disable implicit copy and assignment operators */
        MCP2515(const MCP2515&) = delete;
        MCP2515 &operator=(const MCP2515&) = delete;
    };
}