SmartPDCode/pro/src/cascade_slave.c

#include "modbus.h"
#include "common.h"
#include "list.h"
#include "switch_ctrl.h"
#include "cascade.h"



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

static mmap_modbus_t modbus_single[] = {
    {.offset = 4000},
    {.offset = 4001},
    {.offset = 4769},
    {.offset = 4777},
    {.offset = 4841},
    {.offset = 4905},
};

static mmap_modbus_t modbus_dc[] = {
    {.offset = 6000},
    {.offset = 6001},
    {.offset = 6002},
    {.offset = 6003},
    {.offset = 6004},
    {.offset = 6005},
};



int cascade_slave_map_init(cascade_handle_t *cas)
{
    GlobalDeviceManager* mgr = get_dm();

    if(mgr->_global_device_info->product_pwr_type == SmartPDU_AC)       // single AC
    {
        cas->map = modbus_mapping_new_start_address(0,0,0,0,4000,5000,0,0);     //3000 ge
        modbus_single[0].addr = &mgr->single_mmap->dev_chn;
        modbus_single[1].addr = &mgr->single_mmap->all_ch;
        modbus_single[2].addr = &mgr->single_mmap->total_valtage;
        modbus_single[3].addr = &mgr->single_mmap->chn_status;
        modbus_single[4].addr = &mgr->single_mmap->open_delay;
        modbus_single[5].addr = &mgr->single_mmap->close_delay;
        printf("single address init 4000\n");
    }else if(mgr->_global_device_info->product_pwr_type == SmartPDU_DC)
    {
        cas->map = modbus_mapping_new_start_address(0,0,0,0,6000,5000,0,0);     //3000 ge
        modbus_dc[0].addr = &mgr->dc_mmap->dev_chn;
        modbus_dc[1].addr = &mgr->dc_mmap->i_valtage;
        modbus_dc[2].addr = &mgr->dc_mmap->i_current;
        modbus_dc[3].addr = &mgr->dc_mmap->i_power;
        modbus_dc[4].addr = &mgr->dc_mmap->i_consumption;
        modbus_dc[5].addr = &mgr->dc_mmap->o_pw_info;
        printf("dc address init 4000\n");
    }else
    {
        return -1;
    }
    return 0;
}



void cascade_slave_read(cascade_handle_t *cas,uint32_t addr,uint32_t lenth)
{

    GlobalDeviceManager* mgr = get_dm();
    if(mgr->_global_device_info->product_pwr_type == SmartPDU_AC)
    {
        switch (addr)
        {
            case 4000:
                {
                    uint32_t *base_addr = (uint32_t *)modbus_single[0].addr;
                    uint32_t step = addr - cas->map->start_registers;
                    base_addr = base_addr + (addr - modbus_single[0].offset);
                    uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
                    printf("step = %d   base_addr = 0x%x  map_addr = 0x%x\n", step,base_addr,map_addr);
                    if(lenth < 126)
                    {
                        pthread_mutex_lock(&cas->mutex);
                        memcpy(map_addr, base_addr,2*lenth);
                        pthread_mutex_unlock(&cas->mutex);
                    }
                }
                break;
            case 4001 ... 4768:
            {
                uint32_t *base_addr = (uint32_t *)modbus_single[1].addr;
                uint32_t step = addr - cas->map->start_registers;
                base_addr = base_addr + (addr - modbus_single[1].offset);
                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
                printf("step = %d   base_addr = 0x%x  map_addr = 0x%x\n", step,base_addr,map_addr);
                if(lenth < 126)
                {
                        pthread_mutex_lock(&cas->mutex);
                        memcpy(map_addr, base_addr,2*lenth);
                        pthread_mutex_unlock(&cas->mutex);
                }
            }
            break;
            case 4769 ... 4776:
            {
                uint32_t *base_addr = (uint32_t *)modbus_single[2].addr;
                uint32_t step = addr - cas->map->start_registers;
                base_addr = base_addr + (addr - modbus_single[2].offset);
                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
                if(lenth < 126)
                {
                        pthread_mutex_lock(&cas->mutex);
                        memcpy(map_addr, base_addr,2*lenth);
                        pthread_mutex_unlock(&cas->mutex);
                }
            }
            break;
            case 4777 ... 4840:
            {
                uint32_t *base_addr = (uint32_t *)modbus_single[3].addr;
                uint32_t step = addr - cas->map->start_registers;
                base_addr = base_addr + (addr - modbus_single[3].offset);
                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
                if(lenth < 126)
                {
                        pthread_mutex_lock(&cas->mutex);
                        memcpy(map_addr, base_addr,2*lenth);
                        pthread_mutex_unlock(&cas->mutex);
                }               
            }
            break;
            case 4841 ... 4904:
            {
                uint32_t *base_addr = (uint32_t *)modbus_single[4].addr;
                uint32_t step = addr - cas->map->start_registers;
                base_addr = base_addr + (addr - modbus_single[4].offset);
                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
                if (lenth < 126)
                {
                    pthread_mutex_lock(&cas->mutex);
                    memcpy(map_addr, base_addr, 2 * lenth);
                    pthread_mutex_unlock(&cas->mutex);
                }
            }
            break;
            case 4905 ... 4968:
            {
                uint32_t *base_addr = (uint32_t *)modbus_single[5].addr;
                uint32_t step = addr - cas->map->start_registers;
                base_addr = base_addr + (addr - modbus_single[5].offset);
                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
                if (lenth < 126)
                {
                    pthread_mutex_lock(&cas->mutex);
                    memcpy(map_addr, base_addr, 2 * lenth);
                    pthread_mutex_unlock(&cas->mutex);
                }
            }
            break;
        default:
            break;
        }
    }else if(mgr->_global_device_info->product_pwr_type == SmartPDU_DC)
    {
        switch (addr)
        {
            case 6000:
                {
                    uint32_t *base_addr = (uint32_t *)modbus_dc[0].addr;
                    uint32_t step = addr - cas->map->start_registers;
                    base_addr = base_addr + (addr - modbus_dc[0].offset);
                    uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
                    printf("step = %d   base_addr = 0x%x  map_addr = 0x%x\n", step,base_addr,map_addr);
                    if(lenth < 126)
                    {
                        pthread_mutex_lock(&cas->mutex);
                        memcpy(map_addr, base_addr,2*lenth);
                        pthread_mutex_unlock(&cas->mutex);
                    }
                }
                break;
            case 6001:
            {
                uint32_t *base_addr = (uint32_t *)modbus_dc[1].addr;
                uint32_t step = addr - cas->map->start_registers;
                base_addr = base_addr + (addr - modbus_dc[1].offset);
                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
                if(lenth < 126)
                {
                        pthread_mutex_lock(&cas->mutex);
                        memcpy(map_addr, base_addr,2*lenth);
                        pthread_mutex_unlock(&cas->mutex);
                }
            }
            break;
            case 6002:
            {
                uint32_t *base_addr = (uint32_t *)modbus_dc[2].addr;
                uint32_t step = addr - cas->map->start_registers;
                base_addr = base_addr + (addr - modbus_dc[2].offset);
                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
                if(lenth < 126)
                {
                        pthread_mutex_lock(&cas->mutex);
                        memcpy(map_addr, base_addr,2*lenth);
                        pthread_mutex_unlock(&cas->mutex);
                }
            }
            break;
            case 6003:
            {
                uint32_t *base_addr = (uint32_t *)modbus_dc[3].addr;
                uint32_t step = addr - cas->map->start_registers;
                base_addr = base_addr + (addr - modbus_dc[3].offset);
                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
                if(lenth < 126)
                {
                        pthread_mutex_lock(&cas->mutex);
                        memcpy(map_addr, base_addr,2*lenth);
                        pthread_mutex_unlock(&cas->mutex);
                }
            }
            break;
            case 6004:
            {
                uint32_t *base_addr = (uint32_t *)modbus_dc[4].addr;
                uint32_t step = addr - cas->map->start_registers;
                base_addr = base_addr + (addr - modbus_dc[4].offset);
                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
                if(lenth < 126)
                {
                        pthread_mutex_lock(&cas->mutex);
                        memcpy(map_addr, base_addr,2*lenth);
                        pthread_mutex_unlock(&cas->mutex);
                }
            }
            break;
            case 6005 ... 6260:
            {
                uint32_t *base_addr = (uint32_t *)modbus_dc[5].addr;
                uint32_t step = addr - cas->map->start_registers;
                base_addr = base_addr + (addr - modbus_dc[5].offset);
                uint16_t *map_addr = (uint16_t *)&(cas->map->tab_registers[step]);
                if(lenth < 126)
                {
                        pthread_mutex_lock(&cas->mutex);
                        memcpy(map_addr, base_addr,2*lenth);
                        pthread_mutex_unlock(&cas->mutex);
                }
            }
            break;
            default:
                break;
        }
    }
}



void cascade_slave_write(cascade_handle_t *cas, uint32_t addr, uint16_t val)
{   
    GlobalDeviceManager* mgr = get_dm();
    uint16_t buff[128] = {0};
    if(mgr->_global_device_info->product_pwr_type == SmartPDU_AC)   
    {
        switch(addr)
        {
            case 5128 ... 5191:
            {
                int start_chn = addr - 5128 + 1;
                GlobalPowerManger* _globalPowerMangerTemp = NULL ;

                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                {
                        
                        if(_globalPowerMangerTemp==NULL)
                            break;
                        if((start_chn+1) == _globalPowerMangerTemp->product_ch_id)
                        {
                            int ret=g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp,
                            _globalPowerMangerTemp->product_saddr,
                            _globalPowerMangerTemp->product_ch_addr, 
                            val,false);
                          //  printf("ret = %d 0x%x\n",ret,val);
                            break;
                        }
                }

            }
            break;
            case 5192:
            {
                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                {
                    if(_globalPowerMangerTemp==NULL)
                    break;
                    int rec=g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,val);
                    //printf("rec = %d 0x%x\n",rec,val);
                }
            }
            break;

            default:
            break;
        }
    }else if(mgr->_global_device_info->product_pwr_type == SmartPDU_DC)
    {
        switch (addr)
        {
            case 6756 ... 6819:
            {
                int start_chn = addr - 6756 + 1;
                GlobalPowerManger* _globalPowerMangerTemp = NULL;

                    list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                    {
                        
                        if(_globalPowerMangerTemp==NULL)
                            break;
                        if((start_chn+1) == _globalPowerMangerTemp->product_ch_id)
                        {
                            int ret=g_switch_set_all_chn_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp,
                            _globalPowerMangerTemp->product_saddr,
                            _globalPowerMangerTemp->product_ch_addr, 
                            val,false);
                            break;
                        }
                    }
            }
            break;
            case 7012:
            {
                
                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                {
                    if(_globalPowerMangerTemp==NULL)
                    break;
                    if(val == 0x1)
                        g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,1);
                }
            }
            break;
            case 7013:
            {
                
                GlobalPowerManger* _globalPowerMangerTemp = NULL ;
                list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                {
                    if(_globalPowerMangerTemp==NULL)
                    break;
                    if(val == 0x1)
                        g_switch_set_all_ctrl(&__globalDeviceManage._globalRelaySampManger,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,0);
                }
            }
            break;
            default:
            break;
        }
    }
}