ctnd/platform/device/plc/simatic_s7_comm.c

#include "plt.h"

void simatic_s7_comm_dac( int idx )
{
    struct simatic_s7_t* dev = &simatic_s7[idx];
    struct comm_t* comm = &dev->comm;
    int start, nb, rc;
    int chanidx = comm->chanidx;
    int addr = comm->adr;
    unsigned short tab_us[128]={0};

    if(comm_get_state(comm) != COMMST_NORMAL){
        return;
    }
    comm_start_cal_dac_timing(comm);

    nb = 100;
    start = 0;
    chan_lock(chanidx);
    usleep(100000); // 100ms
    rc = chan_read_holdingregisters_with_retry( chanidx, addr, start, nb, tab_us);
    if( rc < 0){
        comm_set_state(comm, COMMST_ERR);
    }
    chan_unlock(chanidx);
        
    if( rc == 0 ){ // read ok
        dev->hb_from_dev = tab_us[1 - start];
        dev->dc_non_load_sw_stat = tab_us[2 - start];
        dev->dc_main_fuse_stat = tab_us[3 - start];
        dev->dc_surge_arrester_stat = tab_us[4 - start];    
        dev->ac_main_sw_stat = tab_us[5 - start];
        dev->power_supply_mcb_status = tab_us[6 - start];
        dev->mcb_status = tab_us[7 - start];
        dev->power_supply_24v_stat = tab_us[8 - start];
        dev->e_stop_btn_stat = tab_us[9 - start];
        dev->reset_push_btn_stat = tab_us[10 - start];
        dev->safety_relay_stat = tab_us[11 - start];
        dev->ac_surge_arrester_stat = tab_us[12 - start];
        dev->pcs_remote_trip_fb = tab_us[13 - start];

        dev->door_limit_sw_stat[1] = tab_us[16 - start]; 
        dev->door_limit_sw_stat[2] = tab_us[17 - start]; 
        dev->door_limit_sw_stat[3] = tab_us[18 - start]; 
        dev->door_limit_sw_stat[4] = tab_us[19 - start]; 
        dev->door_limit_sw_stat[5] = tab_us[20 - start]; 
        dev->door_limit_sw_stat[6] = tab_us[21 - start]; 
        dev->door_limit_sw_stat[7] = tab_us[22 - start]; 
        dev->door_limit_sw_stat[8] = tab_us[23 - start]; 
        dev->door_limit_sw_stat[9] = tab_us[14 - start];            

        dev->fire_stat1_alarm = tab_us[24 - start];
        dev->fire_stat2_alarm = tab_us[25 - start];
        dev->fire_alarm = tab_us[26 - start];
        dev->fire_fault = tab_us[27 - start];
        dev->gas_alarm1 = tab_us[28 - start];
        dev->gas_alarm2 = tab_us[29 - start];

        dev->bms_pwrspl_ctrl_rly = tab_us[48 - start];
        dev->pcs_shutdown_ctrl_rly = tab_us[49 - start];
        dev->safety_relay_shutdown_ctrl_rly = tab_us[50 - start];
        dev->main_sw_trip_ctrl_rly = tab_us[51 - start];
        dev->safety_relay_reset_rly = tab_us[52 - start];
        dev->ems_pwrspl_reset_rly = tab_us[53 - start];
        dev->fan_ctrl_rly1 = tab_us[56 - start];
        dev->fan_ctrl_rly2 = tab_us[57 - start];

        dev->transf_temp = *(SHORT*)&tab_us[58 - start]/10;
        dev->transf_temp_120_alarm = tab_us[74 - start];
        dev->transf_temp_130_alarm = tab_us[75 - start];

        dev->ems_reset_sig = tab_us[76 - start];
        dev->ems_safety_relay_reset_sig = tab_us[77 - start];
        dev->ems_pwrspl_reset_sig = tab_us[78 - start];
        dev->ems_safety_relay_off_sig = tab_us[79 - start];

        dev->transf_alarm_temp = tab_us[96 - start] / 10;
        dev->transf_err_temp = tab_us[97 - start] / 10;


        comm_stop_cal_dac_timing(comm);            
    }
}

int simatic_s7_set_dev_emshb(int idx, int val)
{
    int ret = 0;

    struct simatic_s7_t* dev = &simatic_s7[idx];
    struct comm_t* comm = &dev->comm;

    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int regaddr = 0;

    chan_lock(chanidx);
    usleep(100000); // 100ms
    ret = chan_write_single_register_with_retry(chanidx, addr, regaddr, val);
    chan_unlock(chanidx);

    return ret;
}

int simatic_s7_set_dev_pcs_shutdown(int idx, int val)
{
    int ret = 0;

    struct simatic_s7_t* dev = &simatic_s7[idx];
    struct comm_t* comm = &dev->comm;

    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int regaddr = 49;  

    chan_lock(chanidx);
    usleep(100000); // 100ms
    ret = chan_write_single_register_with_retry(chanidx, addr, regaddr, val);
    chan_unlock(chanidx);

    return ret;
}


int simatic_s7_set_dev_main_sw_trip(int idx, int val)
{
    int ret = 0;

    struct simatic_s7_t* dev = &simatic_s7[idx];
    struct comm_t* comm = &dev->comm;

    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int regaddr = 51;  

    chan_lock(chanidx);
    usleep(100000); // 100ms
    ret = chan_write_single_register_with_retry(chanidx, addr, regaddr, val);
    chan_unlock(chanidx);

    return ret;
}

int simatic_s7_set_dev_ems_reset_signal(int idx, int val)
{
    int ret = 0;

    struct simatic_s7_t* dev = &simatic_s7[idx];
    struct comm_t* comm = &dev->comm;

    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int regaddr = 76;  

    chan_lock(chanidx);
    usleep(100000); // 100ms
    ret = chan_write_single_register_with_retry(chanidx, addr, regaddr, val);
    chan_unlock(chanidx);

    return ret;
}


int simatic_s7_set_dev_ems_safety_relay_reset_signal(int idx, int val)
{
    int ret = 0;

    struct simatic_s7_t* dev = &simatic_s7[idx];
    struct comm_t* comm = &dev->comm;

    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int regaddr = 77;  

    chan_lock(chanidx);
    usleep(100000); // 100ms
    ret = chan_write_single_register_with_retry(chanidx, addr, regaddr, val);
    chan_unlock(chanidx);

    return ret;
}

int simatic_s7_set_dev_ems_safety_relay_off_signal(int idx, int val)
{
    int ret = 0;

    struct simatic_s7_t* dev = &simatic_s7[idx];
    struct comm_t* comm = &dev->comm;

    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int regaddr = 79;  

    chan_lock(chanidx);
    usleep(100000); // 100ms
    ret = chan_write_single_register_with_retry(chanidx, addr, regaddr, val);
    chan_unlock(chanidx);

    return ret;
}


int simatic_s7_set_dev_ems_pwrspl_reset_signal(int idx, int val)
{
    int ret = 0;

    struct simatic_s7_t* dev = &simatic_s7[idx];
    struct comm_t* comm = &dev->comm;

    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int regaddr = 78;  

    chan_lock(chanidx);
    usleep(100000); // 100ms
    ret = chan_write_single_register_with_retry(chanidx, addr, regaddr, val);
    chan_unlock(chanidx);

    return ret;
}


int simatic_s7_set_dev_fanrly1(int idx, int val)
{
    int ret = 0;

    struct simatic_s7_t* dev = &simatic_s7[idx];
    struct comm_t* comm = &dev->comm;

    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int regaddr = 56;  

    chan_lock(chanidx);
    usleep(100000); // 100ms
    ret = chan_write_single_register_with_retry(chanidx, addr, regaddr, val);
    chan_unlock(chanidx);

    return ret;
}


int simatic_s7_set_dev_40099(int idx, int val)
{
    int ret = 0;

    struct simatic_s7_t* dev = &simatic_s7[idx];
    struct comm_t* comm = &dev->comm;

    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int regaddr = 98;  

    chan_lock(chanidx);
    usleep(100000); // 100ms
    ret = chan_write_single_register_with_retry(chanidx, addr, regaddr, val);
    chan_unlock(chanidx);

    return ret;
}

int simatic_s7_set_dev_fanrly2(int idx, int val)
{
    int ret = 0;

    struct simatic_s7_t* dev = &simatic_s7[idx];
    struct comm_t* comm = &dev->comm;

    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int regaddr = 57;  

    chan_lock(chanidx);
    usleep(100000); // 100ms
    ret = chan_write_single_register_with_retry(chanidx, addr, regaddr, val);
    chan_unlock(chanidx);

    return ret;
}

int simatic_s7_set_dev_alarm_temp(int idx, int val)
{
    int ret = 0;

    struct simatic_s7_t* dev = &simatic_s7[idx];
    struct comm_t* comm = &dev->comm;

    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int regaddr = 96;  

    chan_lock(chanidx);
    usleep(100000); // 100ms
    ret = chan_write_single_register_with_retry(chanidx, addr, regaddr, val * 10);
    chan_unlock(chanidx);

    return ret;
}

int simatic_s7_set_dev_err_temp(int idx, int val)
{
    int ret = 0;

    struct simatic_s7_t* dev = &simatic_s7[idx];
    struct comm_t* comm = &dev->comm;

    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int regaddr = 97;  

    chan_lock(chanidx);
    usleep(100000); // 100ms
    ret = chan_write_single_register_with_retry(chanidx, addr, regaddr, val * 10);
    chan_unlock(chanidx);

    return ret;
}

int simatic_s7_comm_init(int idx)
{
    struct simatic_s7_t* dev = &simatic_s7[idx];
    struct comm_t* comm = &dev->comm;

    comm_set_state( comm, COMMST_ERR );
}

int simatic_s7_comm_reset(int idx)
{
    struct simatic_s7_t* dev = &simatic_s7[idx];
    struct comm_t* comm = &dev->comm;

    comm_set_state( comm, COMMST_NORMAL );
}