InterfaceCAN.h

/*
 * Mbed-OS Microcontroller Library
 * Copyright (c) 2021 Embedded Planet
 * Copyright (c) 2021 ARM Limited
 * SPDX-License-Identifier: Apache-2.0
 *
 * 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 MBED_INTERFACE_CAN_H_
#define MBED_INTERFACE_CAN_H_
 
#include "hal/can_helper.h"
 
#include <cstring>
 
#include "platform/Callback.h"
 
namespace mbed {
 
#ifndef FEATURE_EXPERIMENTAL_API
// Forward declare CAN
class CAN;
#endif
 
/** \defgroup drivers-public-api-can CAN
 * \ingroup drivers-public-api
 */
 
/**
 * \defgroup drivers_CANMessage CANMessage class
 * \ingroup drivers-public-api-can
 * @{
 */
 
/** CANMessage class
 */
class CANMessage : public CAN_Message {
 
public:
    /** Creates empty CAN message.
     */
    CANMessage() : CAN_Message()
    {
        len    = 8U;
        type   = CANData;
        format = CANStandard;
        id     = 0U;
        memset(data, 0, 8);
    }
 
    /** Creates CAN message with specific content.
     *
     *  @param _id      Message ID
     *  @param _data    Mesaage Data
     *  @param _len     Message Data length
     *  @param _type    Type of Data: Use enum CANType for valid parameter values
     *  @param _format  Data Format: Use enum CANFormat for valid parameter values
     */
    CANMessage(unsigned int _id, const unsigned char *_data, unsigned char _len = 8, CANType _type = CANData, CANFormat _format = CANStandard)
    {
        len    = (_len > 8) ? 8 : _len;
        type   = _type;
        format = _format;
        id     = _id;
        memcpy(data, _data, len);
    }
 
 
    /** Creates CAN message with specific content.
     *
     *  @param _id      Message ID
     *  @param _data    Mesaage Data
     *  @param _len     Message Data length
     *  @param _type    Type of Data: Use enum CANType for valid parameter values
     *  @param _format  Data Format: Use enum CANFormat for valid parameter values
     */
    CANMessage(unsigned int _id, const char *_data, unsigned char _len = 8, CANType _type = CANData, CANFormat _format = CANStandard)
    {
        len    = (_len > 8) ? 8 : _len;
        type   = _type;
        format = _format;
        id     = _id;
        memcpy(data, _data, len);
    }
 
    /** Creates CAN remote message.
     *
     *  @param _id      Message ID
     *  @param _format  Data Format: Use enum CANType for valid parameter values
     */
    CANMessage(unsigned int _id, CANFormat _format = CANStandard)
    {
        len    = 0;
        type   = CANRemote;
        format = _format;
        id     = _id;
        memset(data, 0, 8);
    }
 
    /**
     * "Deep" comparison operator (ie: compare value of each data member)
     */
    bool operator ==(const CANMessage &b) const
    {
        if (id != b.id) {
            return false;
        }
        if (len != b.len) {
            return false;
        }
        if (format != b.format) {
            return false;
        }
        if (type != b.type) {
            return false;
        }
        if (memcmp(data, b.data, len) != 0) {
            return false;
        }
 
        return true;
    }
 
    bool operator !=(const CANMessage &b) const
    {
        return !(*this == b);
    }
};
 
#if DEVICE_CAN_FD
 
/** CANFDMessage class
 */
class CANFDMessage : public CANFD_Message {
 
public:
    /** Creates empty CANFD message.
     */
    CANFDMessage() : CANFD_Message()
    {
        len    = 64U;
        type   = CANData;
        format = CANStandard;
        id     = 0U;
        memset(data, 0, 64);
    }
 
    /** Creates CANFD message with specific content.
     *
     *  @param _id      Message ID
     *  @param _data    Mesaage Data
     *  @param _len     Message Data length
     *  @param _type    Type of Data: Use enum CANType for valid parameter values
     *  @param _format  Data Format: Use enum CANFormat for valid parameter values
     */
    CANFDMessage(unsigned int _id, const unsigned char *_data, unsigned char _len = 64, CANType _type = CANData, CANFormat _format = CANStandard)
    {
        len    = (_len > 64) ? 64 : _len;
        type   = _type;
        format = _format;
        id     = _id;
        memcpy(data, _data, len);
    }
 
 
    /** Creates CANFD message with specific content.
     *
     *  @param _id      Message ID
     *  @param _data    Mesaage Data
     *  @param _len     Message Data length
     *  @param _type    Type of Data: Use enum CANType for valid parameter values
     *  @param _format  Data Format: Use enum CANFormat for valid parameter values
     */
    CANFDMessage(unsigned int _id, const char *_data, unsigned char _len = 64, CANType _type = CANData, CANFormat _format = CANStandard)
    {
        len    = (_len > 64) ? 64 : _len;
        type   = _type;
        format = _format;
        id     = _id;
        memcpy(data, _data, len);
    }
 
    /** Creates CANFD remote message.
     *
     *  @param _id      Message ID
     *  @param _format  Data Format: Use enum CANType for valid parameter values
     */
    CANFDMessage(unsigned int _id, CANFormat _format = CANStandard)
    {
        len    = 0;
        type   = CANRemote;
        format = _format;
        id     = _id;
        memset(data, 0, 64);
    }
 
    /**
     * "Deep" comparison operator (ie: compare value of each data member)
     */
    bool operator ==(const CANFDMessage &b) const
    {
        if (id != b.id) {
            return false;
        }
        if (len != b.len) {
            return false;
        }
        if (format != b.format) {
            return false;
        }
        if (type != b.type) {
            return false;
        }
        if (memcmp(data, b.data, len) != 0) {
            return false;
        }
 
        return true;
    }
 
    bool operator !=(const CANFDMessage &b) const
    {
        return !(*this == b);
    }
};
 
#endif
 
/** @}*/
 
namespace interface {
 
/* Having this as a struct allows interface::CAN and/or mbed::CAN to inherit the enums */
struct can {
 
    enum Mode {
        Reset = 0,
        Normal,
        Silent,
        LocalTest,
        GlobalTest,
        SilentTest
    };
 
    enum IrqType {
        RxIrq = 0,
        TxIrq,
        EwIrq,
        DoIrq,
        WuIrq,
        EpIrq,
        AlIrq,
        BeIrq,
        IdIrq,
 
        IrqCnt
    };
 
// Prevent slicing and user creation of base class.
protected:
    can() = default;
    ~can() = default;
 
public:
 
    /* Copy constructor and copy assignment operators will be deleted in subclasses as well */
    can(const can &) = delete;
    can &operator=(const can &) = delete;
 
};
 
#ifdef FEATURE_EXPERIMENTAL_API
 
// Pure virtual interface for CAN
struct CAN : public interface::can {
 
    virtual ~CAN() = default;
    virtual int frequency(int hz) = 0;
    virtual int write(CANMessage msg) = 0;
    virtual int read(CANMessage &msg, int handle = 0) = 0;
    virtual void reset() = 0;
    virtual void monitor(bool silent) = 0;
    virtual int mode(Mode mode) = 0;
    virtual int filter(unsigned int id, unsigned int mask, CANFormat format = CANAny, int handle = 0) = 0;
    virtual unsigned char rderror() = 0;
    virtual unsigned char tderror() = 0;
    virtual void attach(Callback<void()> func, IrqType type = IrqType::RxIrq) = 0;
};
 
#else
using CAN = ::mbed::CAN;
#endif
 
} // namespace interface
 
#if defined(FEATURE_EXPERIMENTAL_API) && !DEVICE_CAN
using CAN = interface::CAN;
#endif
 
} // namespace mbed
 
#endif /* MBED_INTERFACE_CAN_H_ */