SmartPDCode/f407/applications/mb.c

#include "mb.h"
#include "list.h"


#define MALLOC   malloc
#define FREE     free

typedef struct {
    mb_inst_t  *h;
    uint8_t    mode;
    uint8_t    type;
}mb_conn_t;

typedef struct {
    mb_conn_t  rtu;
    mb_conn_t  tcp;
    
    rt_thread_t tid;
    uint8_t    quit;
    
    handle_t   rx;
    handle_t   tx;
    
}mb_handle_t;
static mb_handle_t mbHandle={0};

typedef void (*thread_fn_t)(void *arg);


static void mb_handle(mb_conn_t *c)
{
    if(c->mode==MB_MODE_MASTER) {
        
    }
    else {
        mb_slave_fsm(c->h);
    }
}

static void mb_thread(void *arg)
{
    mb_handle_t *h=(mb_handle_t*)arg;
    
    while(h->quit==0) {
        mb_handle(&h->rtu);
        //mb_handle(&h->tcp);
    }
    mb_destory(h->rtu.h);
    mb_destory(h->tcp.h);
    h->quit = 2;
}

static void mb_start(mb_handle_t *h, int flag)
{
    if(flag) {
        h->tid = rt_thread_create(NULL, mb_thread, h, 2048, 5, 20);
        if(h->tid==NULL) {
            //LOG_E("___ thread create failed\n");
        }
        
        h->quit = 0;
        rt_thread_startup(h->tid);
    }
    else {
        h->quit = 1;
        while(h->quit!=2);
        rt_thread_delete(h->tid);
    }
}


void* mb_init(mb_para_t *para)
{
    list_cfg_t lc={0,LIST_FULL_FIFO,10};
    mb_handle_t *h=NULL;
    
    if(!para) {
        return NULL;
    }
    
    h = (mb_handle_t*)MALLOC(sizeof(mb_handle_t));
    if(h) {
        memset(h, 0, sizeof(mb_handle_t));
        
        h->rx = list_init(&lc);
        h->tx = list_init(&lc);
        
        mb_setup(h, para);
        mb_start(h, 1);
    }
    
    return h;
}


int mb_setup(void *h, mb_para_t *para)
{
    mb_backend_param_t param={0};
    mb_handle_t *mh=(mb_handle_t*)h;
    
    if(!mh || !para) {
        return -1;
    }
    
    if(para->type==MB_TYPE_RTU) {
        
        if(mh->rtu.h) {
            mb_disconn(mh->rtu.h);
            mb_destory(mh->rtu.h);
        }
        
        param.rtu = para->para.rtu;
        mh->rtu.type = (para->type==MB_TYPE_RTU)?MB_BACKEND_TYPE_RTU:MB_BACKEND_TYPE_TCP;
        mh->rtu.mode = para->mode;
        mh->rtu.h = mb_create(mh->rtu.type, &param);
        if(!mh->rtu.h) {
            return -1;
        }
        
    }
    else if(para->type==MB_TYPE_TCP) {
        
    }
    else {
        return -1;
    }
    
    return 0;
}



int mb_deinit(void *h)
{
    mb_handle_t *mh=(mb_handle_t*)h;
    if(!mh) {
        return -1;
    }
    mb_start(mh, 0);
    list_free(mh->rx);
    list_free(mh->tx);
    FREE(mh);
    
    return 0;
}


//

int mb_read(void *h, uint8_t addr, uint16_t reg, void *data, int len, int timeout)
{
    int r=-1,sz=0;
    mb_handle_t *mh=(mb_handle_t*)h;
    
    if(!mh || !data || len<=0) {
        return -1;
    }
    
    rt_tick_t end = rt_tick_get_millisecond()+timeout;
    while(1) {
        sz = list_size(mh->rx);
        if(sz>0) {
            break;
        }
        rt_thread_mdelay(1);
        
        if(timeout>0 && rt_tick_get_millisecond()>end) {
            sz = list_size(mh->rx);
            break;
        }
    }
    
    if(sz>0) {
        list_node_t *ln=NULL;
        r = list_take_node(mh->rx, &ln, 0);
        if(r==0) {
            node_t *nd=&ln->data;
            
            if(len>=nd->dlen) {
                memcpy(data, nd->buf, nd->dlen);
            }
            else {
                r = -1;
            }
            list_back_node(mh->rx, ln);
        }
    }
    
    return r;
}


int mb_write(void *h, uint8_t addr, uint16_t reg, void *data, int len)
{
    mb_handle_t *mh=(mb_handle_t*)h;
    if(!mh) {
        return -1;
    }
   
    return list_append(mh->tx, 0, data, len);
}