POWERFIP Library : User’s Guide

int pwrfip_init()

void pwrfip_exit()

const struct pwrfip_version *pwrfip_version_get()

int main(int argc, char *argv[])
{
    const struct pwrfip_version *lib_version;

    pwrfip_init();

    /* pwrfip - get lib version */
    lib_version = pwrfip_version_get();

    printf("pwrfip lib: v%d.%d.%d [build date: %02d/%02d/%02d]\n",
        lib_version->info.major,
        lib_version->info.minor,
        lib_version->info.patch,
        lib_version->date.info.month,
        lib_version->date.info.day,
        lib_version->date.info.year);

    pwrfip_exit();

    return 0;
}

int pwrfip_error_get()

const char *pwrfip_strerror(int err)

int pwrfip_device_list_get(struct pwrfip_dev_infos *dev_infos,
                int *dev_cnt)

struct pwrfip_dev *pwrfip_device_open(uint8_t dev_id)

int pwrfip_device_reset(struct pwrfip_dev *dev)

int pwrfip_device_close(struct pwrfip_dev *dev)

int pwrfip_device_infos_get(struct pwrfip_dev *dev,
                struct pwrfip_dev_infos *info)

int pwrfip_device_report_get(struct pwrfip_dev *dev,
                struct pwrfip_dev_report *report)

struct pwrfip_aele *pwrfip_aele_create(struct pwrfip_node *node);

int pwrfip_aele_delete(struct pwrfip_aele *aele)

struct pwrfip_msg *pwrfip_msg_create(
                struct pwrfip_aele *aele, struct pwrfip_msg_cfg *cfg)

static struct pwrfip_msg_cfg prod_msg_cfg = {
    .type = PWRFIP_MSG_TYPE_SEND,
    .tx.channel = PWRFIP_MSG_TX_CH_APER,
    .tx.ack_mode = PWRFIP_MSG_TX_ACK_MODE_SDA,
    /* local data link layer address: 0x0C0000 */
    .hdr.src.seg = 0,
    .hdr.src.lsap = 0x0C00, /* ssap */
    /* remote data link layer address: 0x0C0100 */
    .hdr.dst.seg = 0,
    .hdr.dst.lsap = 0x0C01, /* dsap (=target) */
    .pwrfip_msg_handler = NULL,
};

static struct pwrfip_msg_cfg cons_msg_cfg = {
    .type = PWRFIP_MSG_TYPE_RECV,
    /* remote data link layer address: 0x0C0100 */
    .hdr.src.seg = 0,
    .hdr.src.lsap = 0x0C01, /* ssap */
    /* local data link layer address: 0x0C0000 */
    .hdr.dst.seg = 0,
    .hdr.dst.lsap = 0x0C00, /* dsap (=target) */
    .pwrfip_msg_handler = NULL,
};

int main(int argc, char *argv[])
{
    int i, err = 0;
    struct pwrfip_node_cfg node_cfg;
    struct pwrfip_node *node;
    struct pwrfip_aele *al;
    struct pwrfip_msg *prod_msg, *cons_msg;

    /**
     * Node initialization
     */
    memset(&node_cfg, 0, sizeof(struct pwrfip_node_cfg));
    node_cfg.fip_phy_addr = 0;
    node_cfg.fip_seg_num = 0;
    node_cfg.msg.enable = 1;
    if (node_cfg.msg.enable) {
        /* set rx messaging sensitivity only for messages destined
         * for segment 0 with DSAP values configured for the node
         */
        node_cfg.msg.rx_segment_tab[0] = PWRFIP_MSG_SEG_ACCEPT_LTD;
        node_cfg.msg.rx_fifo_size = 0; /* 0 to set default value (30) */
        node_cfg.msg.tx_aper_fifo_size = 0; /* default value for tx aper channel:
                                             * tx fifo depth = 24 messages
                                             */
        node_cfg.msg.tx_max_repeat = 3; /* 3 tx retries in case of error */
        /* periodic messaging channels are disabled */
        for (i = 0; i < PWRFIP_MSG_TX_CH_PER_CNT; ++i)
            node_cfg.msg.tx_per_fifo_id[i] = 0; /* no id attached */

    }
    /*...: other node configuration fields to fill (ba, handlers...) */
    node = pwrfip_node_init(&node_cfg);
    if (!node) {
        printf("node creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* create an aele context */
    al = pwrfip_aele_create(node);
    if (!al) {
        printf("aele creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* create a tx message */
    prod_msg = pwrfip_msg_create(al, &prod_msg_cfg);
    if (!prod_msg) {
        printf("tx message creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* create a rx message */
    cons_msg = pwrfip_msg_create(al, &cons_msg_cfg);
    if (!cons_msg) {
        printf("rx message creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /**
     * Other tasks
     */
    /* ... */

end:
    /**
     * Node exit
     */
    /*...*/
    return err;
}

int pwrfip_msg_delete(struct pwrfip_msg *msg)

struct pwrfip_var *pwrfip_sm_var_create(
                struct pwrfip_aele *aele, enum pwrfip_sm_var_type type,
                uint8_t node_addr)

int main(int argc, char *argv[])
{
    int err = 0;
    struct pwrfip_node *node;
    struct pwrfip_aele *al;

    /**
     * Node initialization.
     * Note: We assume here that the local node created has a FIP address = 1
     */
    /*...*/

    /**
     * Create an aele context.
     * Note: When the AE/LE is created, the following SM-MPS variables are
     * automatically created: 0x9003, 0x9002, 0x10XY, 0x11XY, 0x14XY where
     * XY is the local node address (here, FIP address = 1).
     * If the node is master (ba active), 0x9002 and 0x9003 variables will
     * be automatically produced and updated by the library; otherwise they
     * will only be consumed.
     * Moreover 0x10XY, 0x11XY, 0x14XY are always automatically produced and
     * updated by the library.
     */
    al = pwrfip_aele_create(node);
    if (!al) {
        printf("aele creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /**
     * Creates other sm-mps variables to consume.
     * Note: In this example, the local station will be connected to the remote
     * stations 2 and 3; and we would like to be able to read their system
     * management variables. So we create them.
     */
    /* => creates consumed SM-MPS variables: 0x1002, 0x1102, 0x1402 */
    pwrfip_sm_var_create(al, PWRFIP_SM_VAR_IDENT, 2);
    pwrfip_sm_var_create(al, PWRFIP_SM_VAR_REPORT, 2);
    pwrfip_sm_var_create(al, PWRFIP_SM_VAR_PRESENCE, 2);

    /* => creates consumed SM-MPS variables: 0x1003, 0x1103, 0x1403 */
    pwrfip_sm_var_create(al, PWRFIP_SM_VAR_IDENT, 3);
    pwrfip_sm_var_create(al, PWRFIP_SM_VAR_REPORT, 3);
    pwrfip_sm_var_create(al, PWRFIP_SM_VAR_PRESENCE, 3);

    /**
     * Other tasks
     */
    /* ... */

end:
    /**
     * Node exit
     */
    /*...*/
    return err;
}

struct pwrfip_var *pwrfip_var_create(struct pwrfip_aele *aele,
                struct pwrfip_var_cfg *cfg)

void sync_var_handler(struct pwrfip_node *node,
    struct pwrfip_var *var, struct pwrfip_event *evt);

static struct pwrfip_var_cfg prod_var_cfg = {
    .type = PWRFIP_VAR_TYPE_PROD,
    .id = 0x3800,
    .prod.payload_bsz = 8,
    .prod.flags = \
        /* enable prod status */
        PWRFIP_VAR_FLAGS_REFRESH | \
        /* enable aper var request */
        PWRFIP_VAR_FLAGS_APER_VAR_REQ | \
        /* enable aper msg request */
        PWRFIP_VAR_FLAGS_APER_MSG_REQ,
    .prod.refreshment_ustime = 80000, /* 80ms */
    .prod.evt_type = PWRFIP_EVT_TYPE_NONE,
    .pwrfip_var_handler = NULL,
};

static struct pwrfip_var_cfg cons_var_cfg = {
    .type = PWRFIP_VAR_TYPE_CONS,
    .id = 0x3801,
    .cons.payload_bsz = 8,
    .cons.flags = \
        /* enable prod status */
        PWRFIP_VAR_FLAGS_REFRESH | \
        /* enable promptness checking */
        PWRFIP_VAR_FLAGS_PROMPT | \
        /* enable pdu + len bytes checking */
        PWRFIP_VAR_FLAGS_CHK_PDU_LEN,
    .cons.promptness_ustime = 100000, /* 100ms */
    .cons.evt_type = PWRFIP_EVT_TYPE_NONE,
    .pwrfip_var_handler = NULL,
};

static struct pwrfip_var_cfg sync_var_cfg = {
    .type = PWRFIP_VAR_TYPE_SYNC,
    .id = 0x3000,
    .pwrfip_var_handler = sync_var_handler,
};

int main(int argc, char *argv[])
{
    int err = 0;
    struct pwrfip_node *node;
    struct pwrfip_aele *al;
    struct pwrfip_var *prod_var, *cons_var, *sync_var;

    /**
     * Node initialization
     */
    /*...*/

    /* create an aele context */
    al = pwrfip_aele_create(node);
    if (!al) {
        printf("aele creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* create a production variable */
    prod_var = pwrfip_var_create(al, &prod_var_cfg);
    if (!prod_var) {
        printf("production variable creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* create a consumption variable */
    cons_var = pwrfip_var_create(al, &cons_var_cfg);
    if (!cons_var) {
        printf("consumption variable creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* create a synchronization variable */
    sync_var = pwrfip_var_create(al, &sync_var_cfg);
    if (!sync_var) {
        printf("synchronization variable creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /**
     * Other tasks
     */
    /* ... */

end:
    /**
     * Node exit
     */
    /*...*/
    return err;
}

int pwrfip_var_delete(struct pwrfip_var *var)

struct pwrfip_ba_mcycle *pwrfip_ba_mcycle_create(
                            struct pwrfip_node *node,
                            struct pwrfip_ba_mcycle_cfg *cfg)

#define TST_BA_PER_REQ_COUNT 3
static struct pwrfip_ba_request tst_ba_per_req[TST_BA_PER_REQ_COUNT] = {
    {
        .type = PWRFIP_BA_ID_DAT,
        .id = 0x3800,
    },
    {
        .type = PWRFIP_BA_ID_DAT,
        .id = 0x3801,
    },
    {
        .type = PWRFIP_BA_ID_DAT,
        .id = 0x9003,
    },
};

static struct pwrfip_ba_wind_cfg tst_ba_wind_cfg[2][4] = {
    /* ba mcycle 1 */
    {
        /* 1 - periodic variable window */
        {
            .type = PWRFIP_BA_WIND_PER,
            .per.req_cnt = TST_BA_PER_REQ_COUNT,
            .per.req_list = &tst_ba_per_req[0],
        },
        /* 2 - aperiodic message window */
        {
            .type = PWRFIP_BA_WIND_APER_MSG,
            .aper_msg.end_ustime = 15000,
        },
        /* 3 - aperiodic variable window */
        {
            .type = PWRFIP_BA_WIND_APER_VAR,
            .aper_var.end_ustime = 35000,
            .aper_var.enable_testp = 1, /* enable presence test if no other
                                         * request to dispatch */
        },
        /* 4 - resync wait window */
        {
            .type = PWRFIP_BA_WIND_WAIT,
            .wait.end_ustime = 40000,
            .wait.is_silent = 0, /* fill window with padding frames */
            .wait.is_ext_resync = 0, /* internal resynchronization */
        },
    },
    /* ba mcycle 2 */
    {
        /* 1 - periodic variable window */
        {
            .type = PWRFIP_BA_WIND_PER,
            .per.req_cnt = TST_BA_PER_REQ_COUNT,
            .per.req_list = &tst_ba_per_req[0],
        },
        /* 2 - aperiodic message window */
        {
            .type = PWRFIP_BA_WIND_APER_MSG,
            .aper_msg.end_ustime = 75000,
        },
        /* 3 - resync wait window */
        {
            .type = PWRFIP_BA_WIND_WAIT,
            .wait.end_ustime = 80000,
            .wait.is_silent = 0, /* fill window with padding frames */
            .wait.is_ext_resync = 0, /* internal resynchronization */
        },
        /* no other window */
        {
            .type = 0,
        }
    },
};

static struct pwrfip_ba_mcycle_cfg tst_ba_mcycle_cfg[2] = {
    /* ba mcycle 1 */
    {
        .wind_cnt = 4,
        .wind_list = &tst_ba_wind_cfg[0][0],
    },
    /* ba mcycle 2 */
    {
        .wind_cnt = 3,
        .wind_list = &tst_ba_wind_cfg[1][0],
    },
};

int main(int argc, char *argv[])
{
    int err = 0;
    struct pwrfip_node *node;
    struct pwrfip_ba_mcycle *mcycle[2];

    /**
     * Node initialization
     */
    /*...*/

    /* create two bus arbiter macrocycles */
    for (i = 0; i < 2; ++i) {
        struct pwrfip_ba_mcycle_cfg *mcycle_cfg = &tst_ba_mcycle_cfg[i];

        mcycle[i] = pwrfip_ba_mcycle_create(node, mcycle_cfg);
        if (!mcycle[i]) {
            /* get error */*
            printf("macrocycle creation failed: %s\n", pwrfip_strerror(errno));
            err = -1;
            goto end;
        }
    }

    /**
     * Other tasks
     */
    /* ... */

end:
    /**
     * Node exit
     */
    /*...*/
    return err;
}

int pwrfip_ba_mcycle_delete(struct pwrfip_ba_mcycle *mcycle)

int pwrfip_ba_startup_calculate(uint32_t *stup_ustime, uint32_t *elec_ustime,
        struct pwrfip_ba_startup_cfg *cfg)

int pwrfip_ba_start(struct pwrfip_ba_mcycle *mcycle)

int pwrfip_ba_stop(struct pwrfip_node *node)

int pwrfip_ba_commute(struct pwrfip_ba_mcycle *mcycle)

int pwrfip_ba_status_get(struct pwrfip_node *node, struct pwrfip_ba_status *status)

int pwrfip_msg_send(struct pwrfip_msg *msg)

static struct pwrfip_msg_cfg prod_msg_cfg = {
    .type = PWRFIP_MSG_TYPE_SEND,
    .tx.channel = PWRFIP_MSG_TX_CH_APER,
    .tx.ack_mode = PWRFIP_MSG_TX_ACK_MODE_SDA,
    /* local data link layer address: 0x0C0000 */
    .hdr.src.seg = 0,
    .hdr.src.lsap = 0x0C00, /* ssap */
    /* remote data link layer address: 0x0C0100 */
    .hdr.dst.seg = 0,
    .hdr.dst.lsap = 0x0C01, /* dsap (=target) */
    .pwrfip_msg_handler = NULL,
};

int main(int argc, char *argv[])
{
    int i, err = 0;
    struct pwrfip_node *node;
    struct pwrfip_aele *al;
    struct pwrfip_msg *prod_msg;
    uint16_t w_counter = 0;

    /**
     * Node initialization
     */
    /*...*/

    /* create an aele context */
    al = pwrfip_aele_create(node);
    if (!al) {
        printf("aele creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* create a production message */
    prod_msg = pwrfip_msg_create(al, &prod_msg_cfg);
    if (!prod_msg) {
        printf("production message creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* node startup (slave) */
    err = pwrfip_node_start(al, NULL, 0);
    if (err) {
        printf("node startup failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* writing loop */
    for(;;) {
        /* update msg payload */
        w_counter++;
        prod_msg->bsz = sizeof(w_counter);
        memcpy(prod_msg->buffer, &w_counter, prod_msg->bsz);

        /* send it to fip network */
        if (pwrfip_msg_send(prod_msg)) {
            printf("w_msg[header: src=0x%08x dst=0x%08x] failed: %s\n",
                prod_msg->hdr.src.addr, prod_msg->hdr.dst.addr,
                pwrfip_strerror(errno));
            /* we consider this error as fatal error; so we
             * stop the test */
            break;
        }

        /* check msg state errors */
        if (prod_msg->error) {
            printf("w_msg[header: src=0x%08x dst=0x%08x] state error: %d\n",
                prod_msg->hdr.src.addr, prod_msg->hdr.dst.addr,
                prod_msg->error);
        }

        usleep(100000); /* 100ms */
    }

end:
    /**
     * Node exit
     */
    /*...*/
    return err;
}

int pwrfip_msg_tx_channel_purge(struct pwrfip_node *node,
                enum pwrfip_msg_tx_channel channel,
                uint16_t *purge_cnt, uint8_t *ch_error);

struct pwrfip_node *pwrfip_node_init(struct pwrfip_node_cfg *cfg)

void usr_rst_handler(struct pwrfip_node *node)
{
    /* calling the reset function for a pci/pcie device */
    if (pwrfip_device_reset(node->infos->cfg.dev)) {
        printf("reset failed: %s\n", pwrfip_strerror(errno));
        return;
    }
    _print(src, evt, "reset coprocessor component (powerfip) done\n");
}

void usr_err_handler(struct pwrfip_node *node,
        enum pwrfip_error_code code)
{
    printf("error_handler: %s (err_code=%d)\n",
        pwrfip_strerror(code), code);
}

int main(int argc, char *argv[])
{
    int err = 0;
    struct pwrfip_dev *dev;
    struct pwrfip_node *node;
    struct pwrfip_node_cfg cfg;

    /* pwrfip lib initialization [mandatory] */
    if (pwrfip_init()) {
        printf("cannot init pwrfip library: %s\n",
            pwrfip_strerror(errno));
        return -1;
    }

    /* open a pci/pcie device (1st index) */
    dev = pwrfip_device_open(1);
    if (!dev) {
        printf("cannot open device: %s\n",
            pwrfip_strerror(errno));
        pwrfip_exit();
        return -1;
    }

    /**
     * Node initialization:
     * Minimal set-up for a PCI/PCIe device
     */
    cfg.fip_phy_addr = 1; /* fip node addr = 0x01 */
    cfg.fip_seg_num = 0; /* fip node belongs to fip segment 0 */
    cfg.fip_frm_type = PWRFIP_FRM_WORLDFIP; /* WorldFIP frame (IEC) */
    cfg.fip_bitrate = PWRFIP_BITRATE_1M; /* 1Mbps */
    cfg.turn_around_ustime = 0; /* default TR time for 1Mbps (30us) */
    cfg.silence_ustime = 0; /* default TS time for 1Mbps (150us) */
    cfg.enable_bimedium = 0; /* mono-medium topology (just one channel) */
    cfg.msg.enable = 0; /* fip messaging not supported */
    cfg.ba.enable = 0; /* no master capability for this node */
    cfg.ident.manufacturer_name = "MyVendorName\0";
    cfg.ident.model_name = "MyModelName\0";
    cfg.ident.revision = 0x10; /* v1.0 */
    cfg.dev = dev; /* coprocessor attachment: pci/pcie device to bind */
    cfg.pwrfip_error_handler = usr_err_handler; /* local handler to notify
                                                   the internal errors of
                                                   the library */
    cfg.pwrfip_reset_handler = usr_rst_handler; /* local handler to reset
                                                   the bound device */

    node = pwrfip_node_init(&cfg);
    if (!node) {
        printf("node initialization failed: %s\n",
            pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /**
     * Other tasks
     */
    /* ... */

end:
    /**
     * Node exit
     */
    /*...*/

    /* close device */
    pwrfip_device_close(dev);

    /* pwrfip lib exit [mandatory] */
    pwrfip_exit();
    return err;
}

int pwrfip_node_exit(struct pwrfip_node *node)

int pwrfip_node_status_get(struct pwrfip_node *node,
                struct pwrfip_node_status *status)

static const char *pwrfip_node_state_str[_PWRFIP_NODE_STATE_MAX] = {
    /* PWRFIP_NODE_STATE_INITIAL */
    "initial",
    /* PWRFIP_NODE_STATE_LOADED */
    "loaded",
    /* PWRFIP_NODE_STATE_READY */
    "ready",
    /* PWRFIP_NODE_STATE_RUNNING */
    "running",
};

static const char *pwrfip_node_op_str[_PWRFIP_NODE_OP_MAX] = {
    /* _PWRFIP_NODE_OP_UNKNOWN */
    "unknown",
    /* PWRFIP_NODE_OP_WAIT_RX_RP_FRM */
    "rx rp frame",
    /* PWRFIP_NODE_OP_WAIT_TX_RP_FRM */
    "tx rp frame",
    /* PWRFIP_NODE_OP_WAIT_RX_ID_FRM */
    "rx id frame",
    /* PWRFIP_NODE_OP_WAIT_TX_ID_FRM */
    "tx id frame",
};

int main(int argc, char *argv[])
{
    int err = 0;
    struct pwrfip_node *node;
    struct pwrfip_node_status n_status;

    /**
     * Node initialization
     */
    /*...*/

    /* get node status */
    err = pwrfip_node_status_get(node, &n_status);
    if (err) {
        printf("node status getter failed: %s\n", pwrfip_strerror(errno));
        goto end;
    }

    printf("node_status\n");
    printf("  node_state    : %d (%s)\n", n_status.state,
            pwrfip_node_state_str[n_status.state]);
    printf("  node_op       : %d (%s)\n", n_status.op,
            pwrfip_node_op_str[n_status.op]);

    /**
     * Other tasks
     */
    /* ... */

end:
    /**
     * Node exit
     */
    /*...*/
    return err;
}

int pwrfip_node_report_get(struct pwrfip_node *node,
                struct pwrfip_node_report *report)

static const char *pwrfip_node_state_str[_PWRFIP_NODE_STATE_MAX] = {
    /* PWRFIP_NODE_STATE_INITIAL */
    "initial",
    /* PWRFIP_NODE_STATE_LOADED */
    "loaded",
    /* PWRFIP_NODE_STATE_READY */
    "ready",
    /* PWRFIP_NODE_STATE_RUNNING */
    "running",
};

static const char *pwrfip_ba_state_str[_PWRFIP_BA_STATE_MAX] = {
    /* PWRFIP_BA_STATE_INITIAL */
    "initial",
    /* PWRFIP_BA_STATE_READY */
    "ready",
    /* PWRFIP_BA_STATE_STARTING */
    "starting",
    /* PWRFIP_BA_STATE_IDLE */
    "idle",
    /* PWRFIP_BA_STATE_RUNNING */
    "running",
};

static const char *pwrfip_node_op_str[_PWRFIP_NODE_OP_MAX] = {
    /* _PWRFIP_NODE_OP_UNKNOWN */
    "unknown",
    /* PWRFIP_NODE_OP_WAIT_RX_RP_FRM */
    "rx rp frame",
    /* PWRFIP_NODE_OP_WAIT_TX_RP_FRM */
    "tx rp frame",
    /* PWRFIP_NODE_OP_WAIT_RX_ID_FRM */
    "rx id frame",
    /* PWRFIP_NODE_OP_WAIT_TX_ID_FRM */
    "tx id frame",
};

static const char *pwrfip_ba_wind_str[_PWRFIP_BA_WIND_TYPE_MAX] = {
    /* _PWRFIP_BA_WIND_TYPE_NONE */
    "none",
    /* PWRFIP_BA_WIND_PER */
    "periodic",
    /* PWRFIP_BA_WIND_APER_VAR */
    "aper. var",
    /* PWRFIP_BA_WIND_APER_MSG */
    "aper. msg",
    /* PWRFIP_BA_WIND_WAIT */
    "wait",
};

int main(int argc, char *argv[])
{
    int err = 0;
    struct pwrfip_node *node;
    struct pwrfip_node_report n_report; /* full report */
    uint16_t m_state; /* medium state */

    /**
     * Node initialization
     */
    /*...*/

    /**
     * Node startup
     */
    /*...*/

    /* get node report */
    err = pwrfip_node_report_get(node, &n_report);
    if (err) {
        printf("node report getter failed: %s\n", pwrfip_strerror(errno));
        goto end;
    }

    m_state = n_report.medium_status.state;
    printf("** coprocessor report:\n");
    printf("  node_state    : %d (%s)\n", n_report.node_status.state,
            pwrfip_node_state_str[n_report.node_status.state]);
    printf("  node_op       : %d (%s)\n", n_report.node_status.op,
            pwrfip_node_op_str[n_report.node_status.op]);
    printf("  ba_state      : %d (%s)\n", n_report.ba_status.state,
            pwrfip_ba_state_str[n_report.ba_status.state]);
    printf("  ba_window     : %d (%s)\n", n_report.ba_status.window,
            pwrfip_ba_wind_str[n_report.ba_status.window]);
    printf("  medium_state  : 0x%04x\n", m_state);
    printf("    [channel 1]\n");
    printf("      enable    : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH1_VALID) ? "yes": "no");
    printf("      tx_err    : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH1_TX_ERROR) ? "yes": "no");
    printf("      watchdog  : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH1_WATCHDOG) ? "yes": "no");
    printf("    [channel 2]\n");
    printf("      enable    : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH2_VALID) ? "yes": "no");
    printf("      tx_err    : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH2_TX_ERROR) ? "yes": "no");
    printf("      watchdog  : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH2_WATCHDOG) ? "yes": "no");
    printf("  tx_err        :\n");
    printf("    ok          : %d\n", n_report.tx_err.ok);
    printf("    collision   : %d\n", n_report.tx_err.collision);
    printf("    consistency : %d\n", n_report.tx_err.consistency);
    printf("    not_fresh   : %d\n", n_report.tx_err.not_fresh);
    printf("  rx_err        :\n");
    printf("    ok          : %d\n", n_report.rx_err.ok);
    printf("    pre_mis     : %d\n", n_report.rx_err.pre_mis);
    printf("    fsd_mis     : %d\n", n_report.rx_err.fsd_mis);
    printf("    fsd_unk     : %d\n", n_report.rx_err.fsd_unk);
    printf("    fed_mis     : %d\n", n_report.rx_err.fed_mis);
    printf("    crc_bad     : %d\n", n_report.rx_err.crc_bad);
    printf("    pdu_bad     : %d\n", n_report.rx_err.pdu_bad);
    printf("    len_bad     : %d\n", n_report.rx_err.len_bad);
    printf("    not_fresh   : %d\n", n_report.rx_err.not_fresh);
    printf("    not_prompt  : %d\n", n_report.rx_err.not_prompt);

    /**
     * Other tasks
     */
    /* ... */

end:
    /**
     * Node exit
     */
    /*...*/
    return err;
}