/*
 * eth_ecat_eeprom.hpp
 *
 *  Created on: May 2, 2023
 *      Author: algin
 */

#ifndef FREE_RTOS_ETHERNET_INDUSTRY_ETH_ECAT_EEPROM_HPP_
#define FREE_RTOS_ETHERNET_INDUSTRY_ETH_ECAT_EEPROM_HPP_

#include <ethernet_industry/eth_ecat_datagram.hpp>

namespace free_rtos {

namespace eeprom {

class EEPROM {
public:
    EEPROM(datagram::EcatTelegram& telegram)
    : telegram_{telegram} { }

    template<typename TypeT>
    void wait_busy(typename TypeT::TSlaveAddress& slave_address) {
        using TCommand = command::EcatCommand<TypeT, command::RD>;
        volatile uint16_t stat;
        datagram::EcatDatagram<TCommand, volatile uint16_t> datagram{ {{slave_address, ECT_REG_EEPSTAT}}, stat };

        do {
            telegram_.transfer(datagram);
        }while((stat & EC_ESTAT_BUSY) != 0);
    }

    template<typename TypeT, typename DirT>
    void control_register(typename TypeT::TSlaveAddress& slave_address, ec_ecmdtype eeprom_cmd, uint16_t eeprom_address) {
        using TCommand = command::EcatCommand<TypeT, DirT>;
        std::array<uint16_t, 2> request{eeprom_cmd, eeprom_address};
        datagram::EcatDatagram<TCommand, std::array<uint16_t, 2>> datagram{ {{slave_address, ECT_REG_EEPCTL}}, request };

        telegram_.transfer(datagram);
    }

    template<typename TypeT, typename DirT, typename EcatDgDataT>
    void data_register(typename TypeT::TSlaveAddress& slave_address, EcatDgDataT& data) {
        using TCommand = command::EcatCommand<TypeT, DirT>;
        datagram::EcatDatagram<TCommand, EcatDgDataT> datagram{ {{slave_address, ECT_REG_EEPDAT}}, data };

        telegram_.transfer(datagram);
    }

    template<typename TypeT, typename EcatDgDataT>
    void read(typename TypeT::TSlaveAddress& slave_address, uint16_t eeprom_address, EcatDgDataT& data) {
        wait_busy<TypeT>(slave_address);

        control_register<TypeT, command::WR>(slave_address, EC_ECMD_READ, eeprom_address);

        wait_busy<TypeT>(slave_address);

        data_register<TypeT, command::RD, EcatDgDataT>(slave_address, data);
    }

    template<typename TypeT, typename EcatDgDataT>
    void write(typename TypeT::TSlaveAddress& slave_address, uint16_t eeprom_address, EcatDgDataT& data) {
        wait_busy<TypeT>(slave_address);

        data_register<TypeT, command::WR, EcatDgDataT>(slave_address, data);

        wait_busy<TypeT>(slave_address);

        control_register<TypeT, command::WR>(slave_address, EC_ECMD_WRITE, eeprom_address);
    }

private:
    datagram::EcatTelegram& telegram_;
};

}

}



#endif /* FREE_RTOS_ETHERNET_INDUSTRY_ETH_ECAT_EEPROM_HPP_ */