1

#include <pthread.h>

     2

#include "iec_types_all.h"

     3

#include "POUS.h"

     4

#include "config.h"

     5

#include "beremiz.h"

     6

     7

#define HMI_BUFFER_SIZE %(buffer_size)d

     8

     9

/* PLC reads from that buffer */

    10

static char rbuf[HMI_BUFFER_SIZE];

    11

    12

/* PLC writes to that buffer */

    13

static char wbuf[HMI_BUFFER_SIZE];

    14

    15

static pthread_mutex_t wbuf_mutex = PTHREAD_MUTEX_INITIALIZER;

    16

static pthread_mutex_t rbuf_mutex = PTHREAD_MUTEX_INITIALIZER;

    17

    18

%(extern_variables_declarations)s

    19

    20

typedef const struct {

    21

    void *ptr;

    22

    __IEC_types_enum type;

    23

    uint32_t buf_index;

    24

    uint32_t flags;

    25

} hmi_tree_item_t;

    26

    27

static hmi_tree_item_t hmi_tree_item[] = {

    28

%(variable_decl_array)s

    29

};

    30

    31

typedef void(*hmi_tree_iterator)(hmi_tree_item_t*);

    32

void traverse_hmi_tree(hmi_tree_iterator fp)

    33

{

    34

    unsigned int i;

    35

    for(i = 0; i < sizeof(hmi_tree_item)/sizeof(hmi_tree_item_t); i++){

    36

        hmi_tree_item_t *dsc = &hmi_tree_item[i];

    37

        if(dsc->type != UNKNOWN_ENUM) 

    38

            (*fp)(dsc);

    39

    }

    40

}

    41

    43

    45

    46

void write_iterator(hmi_tree_item_t *dsc)

    47

{

    48

    void *dest_p = &wbuf[dsc->buf_index];

    49

    void *real_value_p = NULL;

    50

    char flags = 0;

    51

    52

    void *visible_value_p = UnpackVar(dsc, &real_value_p, &flags);

    53

    54

    memcpy(dest_p, visible_value_p, __get_type_enum_size(dsc->type));

    55

}

    56

    57

void read_iterator(hmi_tree_item_t *dsc)

    58

{

    59

    void *src_p = &rbuf[dsc->buf_index];

    60

    void *real_value_p = NULL;

    61

    char flags = 0;

    62

    63

    void *visible_value_p = UnpackVar(dsc, &real_value_p, &flags);

    64

    65

    memcpy(visible_value_p, src_p, __get_type_enum_size(dsc->type));

    66

}

    67

    68

int __init_svghmi()

    69

{

    70

    bzero(rbuf,sizeof(rbuf));

    71

    bzero(wbuf,sizeof(wbuf));

    72

    73

    return 0;

    74

}

    75

    76

void __cleanup_svghmi()

    77

{

    78

}

    79

    80

void __retrieve_svghmi()

    81

{

    82

    if(!pthread_mutex_lock(&rbuf_mutex)){

    83

        traverse_hmi_tree(read_iterator);

    84

        pthread_mutex_unlock(&rbuf_mutex);

    85

    }

    86

}

    87

    88

void __publish_svghmi()

    89

{

    90

    if(!pthread_mutex_lock(&wbuf_mutex)){

    91

        pthread_mutex_unlock(&wbuf_mutex);

    92

    }

    93

}

    94