ctnd/platform/device/ups/e3ks_s_comm.c

#include "plt.h"

#define E3KS_WAIT4STX 0
#define E3KS_WAIT4END 1

/*
Q1回车
UPS 回应: 
(208.4 140.0 220.4 034 59.9 2.05 55.0 00110000回车
代表: 
当前输入电压为： 208.4V.
最近一次输入市电异常时电压为： 140.0V.
当前输出电压为is 220.4V.
当前输出负载百分比为34 %.
当前输入频率为 59.9 Hz.
电池单体电压为： 2.05V.
机器内部温度：  55.0 摄氏度
UPS 状态：UPS 故障, Bypass 动作（旁路供电中）, 未关机
UPS b7b6b5b4b3b2b1b0 置1代表发生， 置0代表不发生
b7  1 : 市电异常
b6  1 : 电池低
b5  1 : 旁路工作
b4  1 : UPS 故障
b3  1 : 保留
b2  1 : 自检中
b1  1 : 接收到关机指令， 关机中
b0  0 : 电池模式提示音消除
*/
static int e3ks_s_parse_rsp(int idx)
{
    struct e3ks_t* dev = &e3ks[idx];
    int ret = 0;
    char buf[128];
    int i;

    if( dev->dbg ){
        log_dbg("%s, rsp:%s", __func__, dev->recv_buf);
    }
    // input voltage
    buf[0] = dev->recv_buf[1];
    buf[1] = dev->recv_buf[2];
    buf[2] = dev->recv_buf[3];
    buf[3] = dev->recv_buf[4];
    buf[4] = dev->recv_buf[5];
    buf[5] = 0;
    dev->input_voltage = atof(buf);

    // output voltage
    buf[0] = dev->recv_buf[13];
    buf[1] = dev->recv_buf[14];
    buf[2] = dev->recv_buf[15];
    buf[3] = dev->recv_buf[16];
    buf[4] = dev->recv_buf[17];
    buf[5] = 0;
    dev->output_voltage = atof(buf);    

    // load occupy
    buf[0] = dev->recv_buf[19];
    buf[1] = dev->recv_buf[20];
    buf[2] = dev->recv_buf[21];
    buf[3] = 0;
    dev->load_occupy = atoi(buf);    

    // internal temp
    buf[0] = dev->recv_buf[33];
    buf[1] = dev->recv_buf[34];
    buf[2] = dev->recv_buf[35];
    buf[3] = dev->recv_buf[36];
    buf[4] = 0;
    dev->temp = atoi(buf);  

    if(dev->recv_buf[38] == '1'){
        dev->line_fault = 1;
    }else{
        dev->line_fault = 0;
    }
    if(dev->recv_buf[39] == '1'){
        dev->bat_low = 1;
    }else{
        dev->bat_low = 0;
    }       
    if(dev->recv_buf[41] == '1'){
        dev->ups_fault = 1;
    }else{
        dev->ups_fault = 0;
    }         
    return ret;
}

static int e3ks_s_recv_rsp(int idx)
{
    struct e3ks_t* dev = &e3ks[idx];
    struct comm_t* comm = &dev->comm;
    int chanidx = comm->chanidx;
    int needprocess = 0;
    int nprocess = 0;
    chan_serial_ringbuffer_element_t e_arr[256];
    int i;
    char recvbyte;
    int* recvst = &dev->recv_st;
    int* recvcnt = &dev->recv_cnt;
    char* recvbuf = dev->recv_buf;
    int ret = -1;
    
    //chan_lock(chanidx);
    needprocess = chan_serial_rxrb_num_items(chanidx);
    if( needprocess > 0 ){
        nprocess = (needprocess>sizeof(e_arr)/sizeof(chan_serial_ringbuffer_element_t))?(sizeof(e_arr)/sizeof(chan_serial_ringbuffer_element_t)):needprocess;
        chan_serial_rxrb_dequeue_arr(chanidx, e_arr, nprocess);
        if( dev->dbg == 1 ){
            log_dbg("%s, got %d bytes:", __func__, nprocess);
        }
    }
    //chan_unlock(chanidx);

    if(nprocess > 0){
        for(i = 0; i < nprocess; i++){
            recvbyte = e_arr[i].c;
            if( dev->dbg == 1 ){
                log_dbg("%s, st:%d, got %02X-%c", __func__, *recvst, recvbyte,recvbyte);
            }
            switch(*recvst){
                case E3KS_WAIT4STX:
                    if(recvbyte == '('){
                        *recvcnt = 0;
                        memset(dev->recv_buf, 0, sizeof(dev->recv_buf));
                        recvbuf[(*recvcnt)++] = recvbyte;
                        *recvst = E3KS_WAIT4END;
                    }
                break;

                case E3KS_WAIT4END:
                    recvbuf[(*recvcnt)++] = recvbyte;
                    if( recvbyte == 0x0D ){
                        return e3ks_s_parse_rsp(idx);
                    }else{
                        if( *recvcnt > sizeof(dev->recv_buf) ){
                            *recvst = E3KS_WAIT4STX;
                        }
                    }           
                break;

                default:
                    *recvst = E3KS_WAIT4STX;
                    break;
            }
        }
    }

    return ret;
}

int e3ks_s_comm_Q1(int idx)
{
    struct e3ks_t* dev = &e3ks[idx];
    struct comm_t* comm = &dev->comm;
    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int i, cnt, rc;
    chan_serial_ringbuffer_element_t e_arr[8];

    e_arr[0].c = 0x51;
    e_arr[1].c = 0x31;
    e_arr[2].c = 0x0D;
    chan_serial_rxrb_init(chanidx);
    chan_serial_txrb_init(chanidx);
    chan_serial_txrb_queue_arr(chanidx, e_arr, 3);
    dev->recv_st = E3KS_WAIT4STX;
    cnt = 100;
    rc = -1;
    while( cnt-- > 0 ){
        usleep(10000); // 10ms
        rc = e3ks_s_recv_rsp(idx);
        if( rc == 0 ){
            break;
        }
    } 

    return rc;
}

void e3ks_s_comm_dac( int idx )
{
    struct e3ks_t* dev = &e3ks[idx];
    struct comm_t* comm = &dev->comm;
    int chanidx = comm->chanidx;
    int trycnt = 3; 
    int ret = -1;
    int rc;

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

    while( trycnt-- > 0 ){
        rc = e3ks_s_comm_Q1(idx);
        if( rc == 0){
            break;
        }else{
            sleep(1); // 1s
        }
    }

    if( rc != 0 ){
        comm_set_state(comm, COMMST_ERR);
    }else{
        comm_stop_cal_dac_timing(comm);
    }
}

int e3ks_s_comm_init(int idx)
{
    struct e3ks_t* dev = &e3ks[idx];
    struct comm_t* comm = &dev->comm;

    comm_set_state( comm, COMMST_ERR );
}

int e3ks_s_comm_reset(int idx)
{
    struct e3ks_t* dev = &e3ks[idx];
    struct comm_t* comm = &dev->comm;

    comm_set_state( comm, COMMST_NORMAL );
}