#include "common.h"



#define DEV_CHN_REG                     (4000)
#define SWITCH_STATUE_REG               (4001)
#define POWER_INFO_REG                  (4002)
#define TEPM_HUM_REG                    (4016)
#define SENCOR_STATUS                   (4018)




enum{
    IP_DEV_CHN,
    IP_SWITCH_STATUE,
    IP_POWER_INFO,
    IP_TEMP_HUM,
    IP_SENCOR_STATUS,
};


enum{
    TYPE_U16,
    TYPE_U32
};


typedef struct mmap_modbus{
    int offset;
    void *addr;             //libmodbus source   addr 
}mmap_modbus_t;



typedef struct { 
    modbus_mapping_t    *map;
}slave_handle_t;

static slave_handle_t slHandle;


modbus_mapping_t    *cascade_slave_map()
{
    return slHandle.map;
}


static inline GlobalDeviceManager* get_dm(void)
{
    return &__globalDeviceManage;
}


static mmap_modbus_t modbus_ip[]={
    [IP_DEV_CHN]            = {.offset = DEV_CHN_REG        },
    [IP_SWITCH_STATUE]      = {.offset = SWITCH_STATUE_REG  },
    [IP_POWER_INFO]         = {.offset = POWER_INFO_REG     },
    [IP_TEMP_HUM]           = {.offset = TEPM_HUM_REG        },
    [IP_SENCOR_STATUS]      = {.offset = SENCOR_STATUS      }
};


int cascade_slave_init(void)
{
    GlobalDeviceManager* mgr=get_dm();
    slave_handle_t *sh=&slHandle;

    sh->map = modbus_mapping_new_start_address(0,0,0,0,DEV_CHN_REG,500,0,0);     //500 ge

    modbus_ip[IP_DEV_CHN].addr = &mgr->cascade_mmap->dev_chn;
    modbus_ip[IP_SWITCH_STATUE].addr = &mgr->cascade_mmap->switch_statues;
    modbus_ip[IP_POWER_INFO] .addr = &mgr->cascade_mmap->o_voltalge;
    modbus_ip[IP_TEMP_HUM] .addr = &mgr->cascade_mmap->tempetratue;
    modbus_ip[IP_SENCOR_STATUS] .addr = &mgr->cascade_mmap->sencor_status;
    printf("single dc address init 4000\n");
    return 0;
}



static void slave_read(slave_handle_t *sh, uint32_t addr,int num,uint32_t reg_type,uint32_t type)
{
    if(addr >= DEV_CHN_REG && addr <= SENCOR_STATUS)
    {
        if(type == TYPE_U16)
        {
            uint16_t *base_addr = (uint16_t *)modbus_ip[reg_type].addr;
            uint32_t step = addr - sh->map->start_registers;
            base_addr = base_addr + (addr - modbus_ip[reg_type].offset);
            uint16_t *map_addr = (uint16_t *)&(sh->map->tab_registers[step]);
            if(num < 126)
            {
                memcpy(map_addr, base_addr,2*num);
            }
        }else
        {
            uint32_t *base_addr = (uint32_t *)modbus_ip[reg_type].addr;
            uint32_t step = addr - sh->map->start_registers;
            base_addr = base_addr + (addr - modbus_ip[reg_type].offset);
            uint32_t *map_addr = (uint32_t *)&(sh->map->tab_registers[step]);
            if(num < 126)
            {
                memcpy(map_addr, base_addr,2*num);
            }
        }
    }
}

void cascade_slave_read(uint32_t addr,uint32_t lenth)

{
    slave_handle_t *sh=&slHandle;

    switch (addr)
    {
        case 4000:
        {
            slave_read(sh,addr,lenth,IP_DEV_CHN,TYPE_U16);
        }
        break;
        case 4001:
        {
            slave_read(sh,addr,lenth,IP_SWITCH_STATUE,TYPE_U16);
        }
        break;
        case 4002 ... 4015:
        {
            slave_read(sh,addr,lenth,IP_POWER_INFO,TYPE_U32);
        }
        break;
        case 4016 ... 4017:
        {
            slave_read(sh,addr,lenth,IP_TEMP_HUM,TYPE_U16);
        }
        break;
        case 4018:
        {
            slave_read(sh,addr,lenth,IP_SENCOR_STATUS,TYPE_U16);
        }
        break;
    default:
        break;
    }
}