/*
 * ModBusRtuSetup.cpp
 *
 *  Created on: 3 июл. 2020 г.
 *      Author: s.maksimenko
 */

#include "ModbusRtu.hh"

#include "../../systemic/Process.hpp"
#include "../../driver/ModbusRtu.hh"

#include "../../systemic/ValueLazyFast.hpp"

namespace application {
namespace drivers {

bool ModbusRtu::input( Environment & env ) {

	return grab ( mpPort, env.rholder.getShared<peripheral::IUartPort> ( links.uart ) ) &&
			grab ( mpMemRes, env.rholder.getShared<std::pmr::memory_resource> ( links.memory ) ) &&
			(mpStsAddrValid = env.statuses.get ( links.enable )) &&
			(mpSigAddrModBus = env.signals.get ( links.address ));

}

ModbusRtu::ModbusRtu ( const Links & links, const Setting & sett,
		const configuration::ProcessConfig & proc ) : links(links), params(proc), cfg(sett) {}

void ModbusRtu::build( Environment & env ) {

	using driver::modbus::ModBusRtu;
	using memories::instance_object;
	using peripheral::IUartPort;

	typedef driver::modbus::ModBusAdu::ModbusCrc CrcType;

	common::crc::CrcTable<CrcType>::Instance().inititialize();

	uint16_t addrModBus = cfg.address ? cfg.address : *mpSigAddrModBus;

	ModBusRtu * pModBusRtu = instance_object<ModBusRtu>(env.static_object_ma,

	                                                    addrModBus,
	                                                    *mpPort,
	                                                    mpMemRes );

	systemic::IProcess & modbusProcess =
	    *instance_object< systemic::Process<ModBusRtu> >(env.static_object_ma, *pModBusRtu);

    systemic::ProcScheduler::ProcessParameter modbusProcParam = {
        .priority = params.priority,
        .period = params.period,
        .phase = params.phase,
        .controlled = false
    };

	env.scheduler.registerProcess(params.processor_id, modbusProcess, modbusProcParam);

	env.rholder.share<driver::modbus::IModBus>( *pModBusRtu, links.modbus_rtu );

    typedef systemic::detail::ValueLazyFast<float, ModBusRtu, &ModBusRtu::getPacketCounter> PacketCounter;
    PacketCounter * counter = memories::instance_object<PacketCounter>( env.static_setup_ma, *pModBusRtu );

    env.signals.add( links.packet_counter, counter->getValue(), counter->getValueOverride(), counter->getBase() );

    typedef systemic::detail::ValueLazyFast<bool, ModBusRtu, &ModBusRtu::isCrcError> CrcError;
    CrcError * crc_error = memories::instance_object<CrcError>( env.static_setup_ma, *pModBusRtu );

    typedef systemic::detail::ValueLazyFast<bool, ModBusRtu, &ModBusRtu::isException> Exception;
    Exception * exception = memories::instance_object<Exception>( env.static_setup_ma, *pModBusRtu );

    env.statuses.add( links.crc_error, crc_error->getValue(), crc_error->getValueOverride(), crc_error->getBase() );
    env.statuses.add( links.incorrect_request, exception->getValue(), exception->getValueOverride(), exception->getBase() );

}

}// namespace drivers
}// namespace application