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 DEFAULT_REFRESH_PERIOD_MS 100

     8

#define HMI_BUFFER_SIZE %(buffer_size)d

     9

    10

/* PLC reads from that buffer */

    11

static char rbuf[HMI_BUFFER_SIZE];

    12

    13

/* PLC writes to that buffer */

    14

static char wbuf[HMI_BUFFER_SIZE];

    15

    16

%(extern_variables_declarations)s

    17

    18

#define ticktime_ns %(PLC_ticktime)d

    19

uint16_t ticktime_ms = (ticktime_ns>1000000)?

    20

                     ticktime_ns/1000000:

    21

                     1;

    22

    23

typedef enum {

    24

    buf_free = 0,

    25

    buf_set,

    26

    buf_tosend

    27

} buf_state_t;

    28

    29

int global_write_dirty = 0;

    30

    31

typedef struct {

    32

    void *ptr;

    33

    __IEC_types_enum type;

    34

    uint32_t buf_index;

    35

    36

    /* publish/write/send */

    37

    long wlock;

    38

    /* zero means not subscribed */

    39

    uint16_t refresh_period_ms;

    40

    uint16_t age_ms;

    41

    42

    buf_state_t wstate;

    43

    44

    /* retrieve/read/recv */

    45

    long rlock;

    46

    buf_state_t rstate;

    47

    48

} hmi_tree_item_t;

    49

    50

static hmi_tree_item_t hmi_tree_item[] = {

    51

%(variable_decl_array)s

    52

};

    53

    54

typedef void(*hmi_tree_iterator)(hmi_tree_item_t*);

    55

void traverse_hmi_tree(hmi_tree_iterator fp)

    56

{

    57

    unsigned int i;

    58

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

    59

        hmi_tree_item_t *dsc = &hmi_tree_item[i];

    60

        if(dsc->type != UNKNOWN_ENUM) 

    61

            (*fp)(dsc);

    62

    }

    63

}

    64

    65

#define __Unpack_desc_type hmi_tree_item_t

    66

    67

%(var_access_code)s

    68

    69

void write_iterator(hmi_tree_item_t *dsc)

    70

{

    71

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

    72

    void *real_value_p = NULL;

    73

    char flags = 0;

    74

    75

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

    76

    77

    /* Try take lock */

    78

    long was_locked = AtomicCompareExchange(&dsc->wlock, 0, 1);

    79

    80

    if(was_locked) {

    81

        /* was locked. give up*/

    82

        return;

    83

    }

    84

    85

    if(dsc->wstate == buf_set){

    86

        /* if being subscribed */

    87

        if(dsc->refresh_period_ms){

    88

            if(dsc->age_ms + ticktime_ms < dsc->refresh_period_ms){

    89

                dsc->age_ms += ticktime_ms;

    90

            }else{

    91

                dsc->wstate = buf_tosend;

    92

            }

    93

        }

    94

    }

    95

    96

    /* if new value differs from previous one */

    97

    if(memcmp(dest_p, visible_value_p, __get_type_enum_size(dsc->type)) != 0){

    98

        /* copy and flag as set */

    99

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

   100

        if(dsc->wstate == buf_free) {

   101

            dsc->wstate = buf_set;

   102

            dsc->age_ms = 0;

   103

        }

   104

        global_write_dirty = 1;

   105

    }

   106

   107

    /* unlock - use AtomicComparExchange to have memory barrier */

   108

    AtomicCompareExchange(&dsc->wlock, 1, 0);

   109

}

   110

   111

struct timespec sending_now;

   112

struct timespec next_sending;

   113

void send_iterator(hmi_tree_item_t *dsc)

   114

{

   115

    while(AtomicCompareExchange(&dsc->wlock, 0, 1)) sched_yield();

   116

   117

    // check for variable being modified

   118

    if(dsc->wstate == buf_tosend){

   119

        // send 

   120

   121

        // TODO call the python callback 

   122

   123

        dsc->wstate = buf_free; 

   124

    }

   125

   126

    AtomicCompareExchange(&dsc->wlock, 1, 0);

   127

}

   128

   129

void read_iterator(hmi_tree_item_t *dsc)

   130

{

   131

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

   132

    void *real_value_p = NULL;

   133

    char flags = 0;

   134

   135

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

   136

   137

   138

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

   139

}

   140

   141

int __init_svghmi()

   142

{

   143

    bzero(rbuf,sizeof(rbuf));

   144

    bzero(wbuf,sizeof(wbuf));

   145

   146

    // TODO - sending pthread condition variable

   147

   148

    return 0;

   149

}

   150

   151

void __cleanup_svghmi()

   152

{

   153

}

   154

   155

void __retrieve_svghmi()

   156

{

   157

    traverse_hmi_tree(read_iterator);

   158

}

   159

   160

void __publish_svghmi()

   161

{

   162

    global_write_dirty = 0;

   163

    traverse_hmi_tree(write_iterator);

   164

    if(global_write_dirty) {

   165

        // TODO : set condition variable to wakeup sending collector

   166

    }

   167

   168

}

   169

   170

void* collect_updates_to_send(void* args){

   171

   172

    // TODO : get callback from args

   173

   174

   175

    // TODO : wait for 

   176

    //        - condition variable

   177

   178

    // TODO add arg to traverse_hmi_tree to pass callback

   179

   180

    traverse_hmi_tree(send_iterator);

   181

   182

}