CANSDOPlugin.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 MetraLabs GmbH (MLAB), GERMANY.
 * All rights reserved.
 * Contact: info@MetraLabs.com
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MetraLabs.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file.  Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MetraLabs (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
 * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE
 * OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLABS" HAS BEEN
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN
 * "AS IS" BASIS, AND "MLAB" HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
 * SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MLAB_CANSDOPLUGIN_H_
#define _MLAB_CANSDOPLUGIN_H_

#include <serialization/GetterSetter.h>

#include <gui/views/CANToolsView.h>
#include <gui/views/CANToolsViewPlugin.h>

#include <QTableWidget>
#include <QVBoxLayout>
#include <QPushButton>
#include <QCompleter>
#include <QLineEdit>
#include <QComboBox>
#include <QStringListModel>
#include <QErrorMessage>

namespace mira { namespace can {


class MLAB_CANGUI_EXPORT CANSDOPlugin : 
    public CANToolsViewPlugin
{
    Q_OBJECT;
    MIRA_META_OBJECT(CANSDOPlugin,
            ("Name",        "CAN SDO viewer")
            ("Category",    "CANOpen")
            ("Description", "Read and write SDOs")
            ("Title",       "SDOs"))

public:

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        r.member("SDOMap",
                 getter<std::vector<SDOInfo>>(&CANSDOPlugin::getSDOInfo, this),
                 setter<std::vector<SDOInfo>>(&CANSDOPlugin::setSDOInfo, this), "");
        r.member("ColumnWidth",
                 getter<std::vector<int>>(&CANSDOPlugin::getColumnWidth, this),
                 setter<std::vector<int>>(&CANSDOPlugin::setColumnWidth, this), "", serialization::IgnoreMissing());
    }

    bool start(uint8 node, mira::can::CANOpenNodeInfo nodeInfo);
    bool stop(uint8 node);

private:

    struct SDOInfo
    {
        enum Access
        {
            NONE = 0x00,
            READ_SDO = 0x01,
            WRITE_SDO = 0x02
        };
        MIRA_ENUM_TO_FLAGS_INCLASS(Access)

        template <typename Reflector>
        void reflect(Reflector& r)
        {
            r.member("Module", 
                     getter<std::string>(boost::bind(&SDOInfo::get<uint16>, this, &module)),
                     setter<std::string>(boost::bind(&SDOInfo::set<uint16>, this, _1, &module)), "");
            r.member("Index",
                     getter<std::string>(boost::bind(&SDOInfo::get<uint16>, this, &index)),
                     setter<std::string>(boost::bind(&SDOInfo::set<uint16>, this, _1, &index)), "");
            r.member("Sub",
                     getter<std::string>(boost::bind(&SDOInfo::get<uint16>, this, &sub)),
                     setter<std::string>(boost::bind(&SDOInfo::set<uint16>, this, _1, &sub)), "");
            r.member("Length",
                     getter<std::string>(&SDOInfo::getLength, this),
                     setter<std::string>(&SDOInfo::setLength, this), "");
            r.member("Access",
                     getter<std::string>(&SDOInfo::getAccess, this),
                     setter<std::string>(&SDOInfo::setAccess, this), "");
            r.member("Description", description, "");
            r.member("Type",
                     getter<std::string>(&SDOInfo::getType, this),
                     setter<std::string>(&SDOInfo::setType, this), "");
        }

        template<typename T>
        std::string get(const T* ptr) const
        {
            return (boost::format("0x%|02X|")%*ptr).str();
        }

        template<typename T>
        void set(const std::string& v, T* ptr)
        {
            *ptr = fromString<FromHex<T>>(v);
        }

        std::string getLength() const
        {
            switch(length)
            {
            case 0:
                return "int8";
                break;
            case 1:
                return "uint8";
                break;
            case 2:
                return "int16";
                break;
            case 3:
                return "uint16";
                break;
            case 4:
                return "int32";
                break;
            case 5:
                return "uint32";
                break;
            }
            return "";
        }

        void setLength(const std::string& v)
        {
            if (v == "int8")
                length = 0;
            if (v== "uint8")
                length = 1;
            if (v== "int16")
                length = 2;
            if (v== "uint16")
                length = 3;
            if (v== "int32")
                length = 4;
            if (v== "uint32")
                length = 5;
        }

        std::string getAccess() const
        {
            std::string a = "none";
            if ((access & READ_SDO) && (access & WRITE_SDO))
                a = "rw";
            else if ((access & READ_SDO))
                a = "ro";
            else if ((access & WRITE_SDO))
                a = "wo";
            return a;
        }

        void setAccess(const std::string& v)
        {
            access = NONE;
            if (v == "ro")
                access = READ_SDO;
            if (v == "wo")
                access = WRITE_SDO;
            if (v == "rw")
                access = READ_SDO | WRITE_SDO;
        }

        std::string getType() const
        {
            switch(type)
            {
            case 0:
                return "dec";
                break;
            case 1:
                return "hex";
                break;
            case 2:
                return "bin";
                break;
            }
            return "";
        }

        void setType(const std::string& v)
        {
            if (v == "dec")
                type = 0;
            if (v== "hex")
                type = 1;
            if (v== "bin")
                type = 2;
        }

        uint16 module;
        uint16 index;
        uint16 sub;
        int length;
        Access access;
        std::string description;
        int type;
        
    };

    void createComboboxes(int row);
    void restore(const std::vector<SDOInfo>& sdoMap);
    SDOInfo getInfoFromRow(int row);

public slots:

    void load();
    void save();
    void clear();
    void addRow();
    void readSDO();
    void writeSDO();
    void selectionChanged(int cbIndex);

protected:
    
    void setSDOInfo(const std::vector<SDOInfo>& info);
    std::vector<SDOInfo> getSDOInfo();
    void setColumnWidth(const std::vector<int>& width);
    std::vector<int> getColumnWidth();

    int findObject(QObject* widget);
    void readRow(int row);

    virtual void initialize();

    QTableWidget* mList;
    bool mLoading;
};


}} // namespaces

#endif /* CANSDOPLUGIN_H_ */