1

#include <pthread.h>

     2

#include <errno.h>

     3

#include "iec_types_all.h"

     4

#include "POUS.h"

     5

#include "config.h"

     6

#include "beremiz.h"

     7

     8

#define DEFAULT_REFRESH_PERIOD_MS 100

     9

#define HMI_BUFFER_SIZE %(buffer_size)d

    10

#define HMI_ITEM_COUNT %(item_count)d

    11

    12

/* PLC reads from that buffer */

    13

static char rbuf[HMI_BUFFER_SIZE];

    14

    15

/* PLC writes to that buffer */

    16

static char wbuf[HMI_BUFFER_SIZE];

    17

    18

%(extern_variables_declarations)s

    19

    20

#define ticktime_ns %(PLC_ticktime)d

    21

uint16_t ticktime_ms = (ticktime_ns>1000000)?

    22

                     ticktime_ns/1000000:

    23

                     1;

    24

    25

typedef enum {

    26

    buf_free = 0,

    27

    buf_set,

    28

    buf_tosend

    29

} buf_state_t;

    30

    31

int global_write_dirty = 0;

    32

    33

typedef struct {

    34

    void *ptr;

    35

    __IEC_types_enum type;

    36

    uint32_t buf_index;

    37

    38

    /* publish/write/send */

    39

    long wlock;

    40

    /* zero means not subscribed */

    41

    uint16_t refresh_period_ms;

    42

    uint16_t age_ms;

    43

    44

    buf_state_t wstate;

    45

    46

    /* retrieve/read/recv */

    47

    long rlock;

    48

    buf_state_t rstate;

    49

    50

} hmi_tree_item_t;

    51

    52

static hmi_tree_item_t hmi_tree_item[] = {

    53

%(variable_decl_array)s

    54

};

    55

    56

static char sendbuf[HMI_BUFFER_SIZE];

    57

    58

typedef void(*hmi_tree_iterator)(hmi_tree_item_t*);

    59

void traverse_hmi_tree(hmi_tree_iterator fp)

    60

{

    61

    unsigned int i;

    62

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

    63

        hmi_tree_item_t *dsc = &hmi_tree_item[i];

    64

        if(dsc->type != UNKNOWN_ENUM) 

    65

            (*fp)(dsc);

    66

    }

    67

}

    68

    69

#define __Unpack_desc_type hmi_tree_item_t

    70

    71

%(var_access_code)s

    72

    73

void write_iterator(hmi_tree_item_t *dsc)

    74

{

    75

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

    76

    void *real_value_p = NULL;

    77

    char flags = 0;

    78

    79

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

    80

    81

    /* Try take lock */

    82

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

    83

    84

    if(was_locked) {

    85

        /* was locked. give up*/

    86

        return;

    87

    }

    88

    89

    if(dsc->wstate == buf_set){

    90

        /* if being subscribed */

    91

        if(dsc->refresh_period_ms){

    92

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

    93

                dsc->age_ms += ticktime_ms;

    94

            }else{

    95

                dsc->wstate = buf_tosend;

    96

            }

    97

        }

    98

    }

    99

   100

    /* if new value differs from previous one */

   101

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

   102

        /* copy and flag as set */

   103

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

   104

        if(dsc->wstate == buf_free) {

   105

            dsc->wstate = buf_set;

   106

            dsc->age_ms = 0;

   107

        }

   108

        global_write_dirty = 1;

   109

    }

   110

   111

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

   112

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

   113

}

   114

   115

struct timespec sending_now;

   116

struct timespec next_sending;

   117

void send_iterator(hmi_tree_item_t *dsc)

   118

{

   119

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

   120

   121

    // check for variable being modified

   122

    if(dsc->wstate == buf_tosend){

   123

        // send 

   124

   125

        // TODO pack data in buffer

   126

   127

        dsc->wstate = buf_free;

   128

    }

   129

   130

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

   131

}

   132

   133

void read_iterator(hmi_tree_item_t *dsc)

   134

{

   135

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

   136

    void *real_value_p = NULL;

   137

    char flags = 0;

   138

   139

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

   140

   141

   142

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

   143

}

   144

   145

static pthread_cond_t svghmi_send_WakeCond = PTHREAD_COND_INITIALIZER;

   146

static pthread_mutex_t svghmi_send_WakeCondLock = PTHREAD_MUTEX_INITIALIZER;

   147

   148

static int continue_collect;

   149

   150

int __init_svghmi()

   151

{

   152

    bzero(rbuf,sizeof(rbuf));

   153

    bzero(wbuf,sizeof(wbuf));

   154

    continue_collect = 1;

   155

   156

    return 0;

   157

}

   158

   159

void __cleanup_svghmi()

   160

{

   161

    pthread_mutex_lock(&svghmi_send_WakeCondLock);

   162

    continue_collect = 0;

   163

    pthread_cond_signal(&svghmi_send_WakeCond);

   164

    pthread_mutex_unlock(&svghmi_send_WakeCondLock);

   165

}

   166

   167

void __retrieve_svghmi()

   168

{

   169

    traverse_hmi_tree(read_iterator);

   170

}

   171

   172

void __publish_svghmi()

   173

{

   174

    global_write_dirty = 0;

   175

    traverse_hmi_tree(write_iterator);

   176

    if(global_write_dirty) {

   177

        pthread_cond_signal(&svghmi_send_WakeCond);

   178

    }

   179

}

   180

   181

/* PYTHON CALLS */

   182

int svghmi_send_collect(uint32_t *size, char **ptr){

   183

   184

    int do_collect;

   185

    pthread_mutex_lock(&svghmi_send_WakeCondLock);

   186

    do_collect = continue_collect;

   187

    if(do_collect){

   188

        pthread_cond_wait(&svghmi_send_WakeCond, &svghmi_send_WakeCondLock);

   189

        do_collect = continue_collect;

   190

    }

   191

    pthread_mutex_unlock(&svghmi_send_WakeCondLock);

   192

   193

   194

    if(do_collect) {

   195

        traverse_hmi_tree(send_iterator);

   196

        /* TODO set ptr and size to something  */

   197

        return 0;

   198

    }

   199

    else

   200

    {

   201

        return EINTR;

   202

    }

   203

}

   204

   205

int svghmi_recv_dispatch(uint32_t size, char *ptr){

   206

    printf("%%*s",size,ptr);

   207

    /* TODO something with ptr and size

   208

        - subscribe

   209

         or

   210

        - spread values

   211

    */

   212

}

   213