/*
 * RUBUSCell.cpp
 *
 *      Author: Aleksey Gerasimenko
 *      gerasimenko.aleksey.n@gmail.com
 */

#include "MODBUSRTU/RUBUSRegister.h"

namespace MODBUSRTU
{
//CONSTRUCTOR
RUBUSRegister::RUBUSRegister():
        m_index(0),
        m_is_read_only(true),
        m_param(0),
        m_type(MODBUSRTU::RUBUS_UNDEFINED)
{}//CONSTRUCTOR

RUBUSRegister::RUBUSRegister(const RUBUSRegister& copyregister):
        m_index(copyregister.m_index),
        m_is_read_only(copyregister.m_is_read_only),
        m_param(copyregister.m_param),
        m_type(copyregister.m_type)
{}


void RUBUSRegister::register_bool  (uint16_t index, uint16_t readonly, bool*     param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BOOL;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_float (uint16_t index, uint16_t readonly, float*    param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_FLOAT;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_uint8 (uint16_t index, uint16_t readonly, uint8_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_UINT8;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_uint16(uint16_t index, uint16_t readonly, uint16_t* param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_UINT16;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_uint32(uint16_t index, uint16_t readonly, uint32_t* param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_UINT32;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_int8  (uint16_t index, uint16_t readonly, int8_t*   param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_INT8;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_int16 (uint16_t index, uint16_t readonly, int16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_INT16;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_int32 (uint16_t index, uint16_t readonly, int32_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_INT32;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit0  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT0;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit1  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT1;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit2  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT2;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit3  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT3;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit4  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT4;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit5  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT5;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit6  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT6;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit7  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT7;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit8  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT8;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit9  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT9;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit10  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT10;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit11  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT11;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit12  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT12;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit13  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT13;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit14  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT14;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit15  (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT15;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit16 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT16;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit17 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT17;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit18 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT18;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit19 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT19;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit20 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT20;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit21 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT21;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit22 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT22;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit23 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT23;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit24 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT24;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit25 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT25;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit26 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT26;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit27 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT27;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit28 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT28;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit29 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT29;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit30 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT30;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//
void RUBUSRegister::register_bit31 (uint16_t index, uint16_t readonly, uint16_t*  param)
{
    m_index = index;
    m_param = param;
    m_type = MODBUSRTU::RUBUS_BIT31;
    m_is_read_only = readonly == 0 ? false : true;
    //
}//
//

uint16_t RUBUSRegister::get_index()
{
    return m_index;
    //
}//
//

bool  RUBUSRegister::is_read_only()
{
    return m_is_read_only;
}//
//

MODBUSRTU::rubus_variant_type_t RUBUSRegister::get_type()
{
    return m_type;
    //
}//
//

MODBUSRTU::RUBUS_REGISTER_32 RUBUSRegister::read_register()
{

    MODBUSRTU::RUBUS_REGISTER_32 _temp = MODBUSRTU::RUBUS_REGISTER_32(0);
    _temp.word.wL.all = 0x0000;
    _temp.word.wH.all = 0x0000;


    switch(m_type)
    {
    case MODBUSRTU::RUBUS_BOOL:   { _temp.b   = *((bool*)     m_param); break;}
    case MODBUSRTU::RUBUS_FLOAT:  { _temp.f   = *((float*)    m_param); break;}
    case MODBUSRTU::RUBUS_UINT8:  { _temp.u8  = *((uint8_t*)  m_param); break;}
    case MODBUSRTU::RUBUS_UINT16: { _temp.u16 = *((uint16_t*) m_param); break;}
    case MODBUSRTU::RUBUS_UINT32: { _temp.u32 = *((uint32_t*) m_param); break;}
    case MODBUSRTU::RUBUS_INT8:   { _temp.i8  = *((int8_t*)   m_param); break;}
    case MODBUSRTU::RUBUS_INT16:  { _temp.i16 = *((int16_t*)  m_param); break;}
    case MODBUSRTU::RUBUS_INT32:  { _temp.i32 = *((int32_t*)  m_param); break;}
    case MODBUSRTU::RUBUS_BIT0:
    {
        _read_bit(_temp.word.wL.all, 0x0001);
        break;
    }
    case MODBUSRTU::RUBUS_BIT1:
    {
        _read_bit(_temp.word.wL.all, 0x0002);
        break;
    }
    case MODBUSRTU::RUBUS_BIT2:
    {
        _read_bit(_temp.word.wL.all, 0x0004);
        break;
    }
    case MODBUSRTU::RUBUS_BIT3:
    {
        _read_bit(_temp.word.wL.all, 0x0008);
        break;
    }
    case MODBUSRTU::RUBUS_BIT4:
    {
        _read_bit(_temp.word.wL.all, 0x0010);
        break;
    }
    case MODBUSRTU::RUBUS_BIT5:
    {
        _read_bit(_temp.word.wL.all, 0x0020);
        break;
    }
    case MODBUSRTU::RUBUS_BIT6:
    {
        _read_bit(_temp.word.wL.all, 0x0040);
        break;
    }
    case MODBUSRTU::RUBUS_BIT7:
    {
        _read_bit(_temp.word.wL.all, 0x0080);
        break;
    }
    case MODBUSRTU::RUBUS_BIT8:
    {
        _read_bit(_temp.word.wL.all, 0x0100);
        break;
    }
    case MODBUSRTU::RUBUS_BIT9:
    {
        _read_bit(_temp.word.wL.all, 0x0200);
        break;
    }
    case MODBUSRTU::RUBUS_BIT10:
    {
        _read_bit(_temp.word.wL.all, 0x0400);
        break;
    }
    case MODBUSRTU::RUBUS_BIT11:
    {
        _read_bit(_temp.word.wL.all, 0x0800);
        break;
    }
    case MODBUSRTU::RUBUS_BIT12:
    {
        _read_bit(_temp.word.wL.all, 0x1000);
        break;
    }
    case MODBUSRTU::RUBUS_BIT13:
    {
        _read_bit(_temp.word.wL.all, 0x2000);
        break;
    }
    case MODBUSRTU::RUBUS_BIT14:
    {
        _read_bit(_temp.word.wL.all, 0x4000);
        break;
    }
    case MODBUSRTU::RUBUS_BIT15:
    {
        _read_bit(_temp.word.wL.all, 0x8000);
        break;
    }
    case MODBUSRTU::RUBUS_BIT16:
    {
        _read_bit(_temp.word.wH.all, 0x0001);
        break;
    }
    case MODBUSRTU::RUBUS_BIT17:
    {
        _read_bit(_temp.word.wH.all, 0x0002);
        break;
    }
    case MODBUSRTU::RUBUS_BIT18:
    {
        _read_bit(_temp.word.wH.all, 0x0004);
        break;
    }
    case MODBUSRTU::RUBUS_BIT19:
    {
        _read_bit(_temp.word.wH.all, 0x0008);
        break;
    }
    case MODBUSRTU::RUBUS_BIT20:
    {
        _read_bit(_temp.word.wH.all, 0x0010);
        break;
    }
    case MODBUSRTU::RUBUS_BIT21:
    {
        _read_bit(_temp.word.wH.all, 0x0020);
        break;
    }
    case MODBUSRTU::RUBUS_BIT22:
    {
        _read_bit(_temp.word.wH.all, 0x0040);
        break;
    }
    case MODBUSRTU::RUBUS_BIT23:
    {
        _read_bit(_temp.word.wH.all, 0x0080);
        break;
    }
    case MODBUSRTU::RUBUS_BIT24:
    {
        _read_bit(_temp.word.wH.all, 0x0100);
        break;
    }
    case MODBUSRTU::RUBUS_BIT25:
    {
        _read_bit(_temp.word.wH.all, 0x0200);
        break;
    }
    case MODBUSRTU::RUBUS_BIT26:
    {
        _read_bit(_temp.word.wH.all, 0x0400);
        break;
    }
    case MODBUSRTU::RUBUS_BIT27:
    {
        _read_bit(_temp.word.wH.all, 0x0800);
        break;
    }
    case MODBUSRTU::RUBUS_BIT28:
    {
        _read_bit(_temp.word.wH.all, 0x1000);
        break;
    }
    case MODBUSRTU::RUBUS_BIT29:
    {
        _read_bit(_temp.word.wH.all, 0x2000);
        break;
    }
    case MODBUSRTU::RUBUS_BIT30:
    {
        _read_bit(_temp.word.wH.all, 0x4000);
        break;
    }
    case MODBUSRTU::RUBUS_BIT31:
    {
        _read_bit(_temp.word.wH.all, 0x8000);
        break;
    }
    }//switch
    //
    return _temp.all;
    //
}//
//

uint16_t RUBUSRegister::write_register(MODBUSRTU::RUBUS_REGISTER_32 data)
{

    MODBUSRTU::RUBUS_REGISTER_32 _temp = MODBUSRTU::RUBUS_REGISTER_32(0);
    _temp.word.wL.all = 0x0000;
    _temp.word.wH.all = 0x0000;

    if(m_is_read_only)
    {
        // register is read only
        // write operation is not allowed
        return 0x0040;
    }
    else
    {
        // writeable register
        switch(m_type)
        {
        case MODBUSRTU::RUBUS_BOOL:   { *((bool*)     m_param) = data.b;   break;}
        case MODBUSRTU::RUBUS_FLOAT:  { *((float*)    m_param) = data.f;   break;}
        case MODBUSRTU::RUBUS_UINT8:  { *((uint8_t*)  m_param) = data.u8;  break;}
        case MODBUSRTU::RUBUS_UINT16: { *((uint16_t*) m_param) = data.u16; break;}
        case MODBUSRTU::RUBUS_UINT32: { *((uint32_t*) m_param) = data.u32; break;}
        case MODBUSRTU::RUBUS_INT8:   { *((int8_t*)   m_param) = data.i8;  break;}
        case MODBUSRTU::RUBUS_INT16:  { *((int16_t*)  m_param) = data.i16; break;}
        case MODBUSRTU::RUBUS_INT32:  { *((int32_t*)  m_param) = data.i32; break;}
        case MODBUSRTU::RUBUS_BIT0:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b00 = data.bit16.b00;
            *((uint16_t*) m_param) = data.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT1:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b01 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT2:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b02 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT3:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b03 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT4:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b04 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT5:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b05 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT6:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b06 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT7:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b07 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT8:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b08 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT9:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b09 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT10:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b10 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT11:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b11 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT12:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b12 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT13:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b13 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT14:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b14 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT15:
        {
            _temp.u16 = *((uint16_t*) m_param);
            _temp.bit16.b15 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.u16;
            break;
        }
        case MODBUSRTU::RUBUS_BIT16:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b16 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        case MODBUSRTU::RUBUS_BIT17:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b17 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        case MODBUSRTU::RUBUS_BIT18:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b18 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        case MODBUSRTU::RUBUS_BIT19:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b19 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        case MODBUSRTU::RUBUS_BIT20:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b20 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        case MODBUSRTU::RUBUS_BIT21:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b21 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        case MODBUSRTU::RUBUS_BIT22:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b22 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        case MODBUSRTU::RUBUS_BIT23:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b23 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        case MODBUSRTU::RUBUS_BIT24:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b24 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        case MODBUSRTU::RUBUS_BIT25:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b25 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        case MODBUSRTU::RUBUS_BIT26:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b26 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        case MODBUSRTU::RUBUS_BIT27:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b27 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        case MODBUSRTU::RUBUS_BIT28:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b28 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        case MODBUSRTU::RUBUS_BIT29:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b29 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        case MODBUSRTU::RUBUS_BIT30:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b30 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        case MODBUSRTU::RUBUS_BIT31:
        {
            _temp.word.wH.all = *((uint16_t*) m_param);
            _temp.bit32.b31 = data.bit16.b00;
            *((uint16_t*) m_param) = _temp.word.wH.all;
            break;
        }
        }//switch
        //
        return 0;
        //
    }//if else
    //
}//
//

inline void RUBUSRegister::_read_bit(uint16_t& auxreg, uint16_t mask)
{
    auxreg = *((uint16_t*) m_param);
    auxreg &= mask;
    auxreg = auxreg == 0 ? 0 : 1;
    //
}//
//
//
} /* namespace MODBUSRTU */