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

#define HMI_HASH_SIZE 8

    12

static uint8_t hmi_hash[HMI_HASH_SIZE] = {%(hmi_hash_ints)s};

    13

    14

/* PLC reads from that buffer */

    15

static char rbuf[HMI_BUFFER_SIZE];

    16

    17

/* PLC writes to that buffer */

    18

static char wbuf[HMI_BUFFER_SIZE];

    19

    20

/* TODO change that in case of multiclient... */

    21

/* worst biggest send buffer. FIXME : use dynamic alloc ? */

    22

static char sbuf[HMI_HASH_SIZE +  HMI_BUFFER_SIZE + (HMI_ITEM_COUNT * sizeof(uint32_t))];

    23

static unsigned int sbufidx;

    24

    25

%(extern_variables_declarations)s

    26

    27

#define ticktime_ns %(PLC_ticktime)d

    28

static uint16_t ticktime_ms = (ticktime_ns>1000000)?

    29

                     ticktime_ns/1000000:

    30

                     1;

    31

    32

typedef enum {

    33

    buf_free = 0,

    34

    buf_set,

    35

    buf_tosend

    36

} buf_state_t;

    37

    38

static int global_write_dirty = 0;

    39

    40

typedef struct {

    41

    void *ptr;

    42

    __IEC_types_enum type;

    43

    uint32_t buf_index;

    44

    45

    /* publish/write/send */

    46

    long wlock;

    47

    buf_state_t wstate;

    48

    49

    /* zero means not subscribed */

    50

    uint16_t refresh_period_ms;

    51

    uint16_t age_ms;

    52

    53

    /* retrieve/read/recv */

    54

    long rlock;

    55

    buf_state_t rstate;

    56

    57

} hmi_tree_item_t;

    58

    59

static hmi_tree_item_t hmi_tree_item[] = {

    60

%(variable_decl_array)s

    61

};

    62

    64

static int traverse_hmi_tree(hmi_tree_iterator fp)

    65

{

    66

    unsigned int i;

    67

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

    68

        int res;

    69

        hmi_tree_item_t *dsc = &hmi_tree_item[i];

    70

        if(res = (*fp)(i, dsc))

    71

            return res;

    72

    }

    73

}

    74

    75

#define __Unpack_desc_type hmi_tree_item_t

    76

    77

%(var_access_code)s

    78

    80

{

    81

    if(AtomicCompareExchange(&dsc->wlock, 0, 1) == 0)

    82

    {

    83

        if(dsc->wstate == buf_set){

    84

            /* if being subscribed */

    85

            if(dsc->refresh_period_ms){

    86

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

    87

                    dsc->age_ms += ticktime_ms;

    88

                }else{

    89

                    dsc->wstate = buf_tosend;

    90

                }

    91

            }

    92

        }

    93

    94

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

    95

        void *real_value_p = NULL;

    96

        char flags = 0;

    97

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

    98

    99

        /* if new value differs from previous one */

   100

        USINT sz = __get_type_enum_size(dsc->type);

   101

        if(memcmp(dest_p, visible_value_p, sz) != 0){

   102

            /* copy and flag as set */

   103

            memcpy(dest_p, visible_value_p, sz);

   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

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

   112

    }

   113

    // else ... : PLC can't wait, variable will be updated next turn

   114

    return 0;

   115

}

   116

   118

{

   119

    int res = 0;

   120

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

   121

   122

    if(dsc->wstate == buf_tosend)

   123

    {

   124

        uint32_t sz = __get_type_enum_size(dsc->type);

   125

        if(sbufidx + sizeof(uint32_t) + sz <  sizeof(sbuf))

   126

        {

   127

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

   128

            void *dst_p = &sbuf[sbufidx];

   129

            memcpy(dst_p, &index, sizeof(uint32_t));

   130

            memcpy(dst_p + sizeof(uint32_t), src_p, sz);

   131

            dsc->wstate = buf_free;

   132

            sbufidx += sizeof(uint32_t) /* index */ + sz;

   133

        }

   134

        else

   135

        {

   136

            res = EOVERFLOW;

   137

        }

   138

    }

   139

   140

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

   141

    return res; 

   142

}

   143

   145

{

   146

    if(AtomicCompareExchange(&dsc->rlock, 0, 1) == 0)

   147

    {

   148

        if(dsc->rstate == buf_set)

   149

        {

   150

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

   151

            void *real_value_p = NULL;

   152

            char flags = 0;

   153

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

   154

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

   155

            dsc->rstate = buf_free;

   156

        }

   157

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

   158

    }

   159

    // else ... : PLC can't wait, variable will be updated next turn

   160

    return 0;

   161

}

   162

   163

inline void update_refresh_period(hmi_tree_item_t *dsc, uint16_t refresh_period_ms)

   164

{

   165

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

   166

    dsc->refresh_period_ms = refresh_period_ms;

   167

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

   168

}

   169

   173

    return 0;

   174

}

   175

   176

static pthread_cond_t svghmi_send_WakeCond = PTHREAD_COND_INITIALIZER;

   177

static pthread_mutex_t svghmi_send_WakeCondLock = PTHREAD_MUTEX_INITIALIZER;

   178

   179

static int continue_collect;

   180

   181

int __init_svghmi()

   182

{

   183

    bzero(rbuf,sizeof(rbuf));

   184

    bzero(wbuf,sizeof(wbuf));

   185

    continue_collect = 1;

   186

   187

    return 0;

   188

}

   189

   190

void __cleanup_svghmi()

   191

{

   192

    pthread_mutex_lock(&svghmi_send_WakeCondLock);

   193

    continue_collect = 0;

   194

    pthread_cond_signal(&svghmi_send_WakeCond);

   195

    pthread_mutex_unlock(&svghmi_send_WakeCondLock);

   196

}

   197

   198

void __retrieve_svghmi()

   199

{

   200

    traverse_hmi_tree(read_iterator);

   201

}

   202

   203

void __publish_svghmi()

   204

{

   205

    global_write_dirty = 0;

   206

    traverse_hmi_tree(write_iterator);

   207

    if(global_write_dirty) {

   208

        pthread_cond_signal(&svghmi_send_WakeCond);

   209

    }

   210

}

   211

   212

/* PYTHON CALLS */

   213

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

   214

   215

    int do_collect;

   216

    pthread_mutex_lock(&svghmi_send_WakeCondLock);

   217

    do_collect = continue_collect;

   218

    if(do_collect)

   219

    {

   220

        pthread_cond_wait(&svghmi_send_WakeCond, &svghmi_send_WakeCondLock);

   221

        do_collect = continue_collect;

   222

    }

   223

    pthread_mutex_unlock(&svghmi_send_WakeCondLock);

   224

   225

    if(do_collect) {

   226

        int res;

   227

        memcpy(&sbuf[0], &hmi_hash[0], HMI_HASH_SIZE);

   228

        sbufidx = HMI_HASH_SIZE;

   229

        if((res = traverse_hmi_tree(send_iterator)) == 0)

   230

        {

   231

            *ptr = &sbuf[0];

   232

            *size = sbufidx;

   233

        }

   234

        return res;

   235

    }

   236

    else

   237

    {

   238

        return EINTR;

   239

    }

   240

}

   241

   242

typedef enum {

   243

    setval = 0,

   244

    reset = 1,

   245

    subscribe = 2,

   246

    unsubscribe = 3

   247

} cmd_from_JS;

   248

   249

int svghmi_recv_dispatch(uint32_t size, const uint8_t *ptr){

   250

    const uint8_t* cursor = ptr + HMI_HASH_SIZE;

   251

    const uint8_t* end = ptr + size;

   252

   254

   255

    /* match hmitree fingerprint */

   257

    {

   258

        printf("svghmi_recv_dispatch MISMATCH !!\n");

   259

        return EINVAL;

   260

    }

   261

   262

    while(cursor < end)

   263

    {

   264

        uint32_t progress;

   265

        cmd_from_JS cmd = *(cursor++);

   266

        switch(cmd)

   267

        {

   268

            case setval:

   269

            {

   270

                uint32_t index = *(uint32_t*)(cursor);

   272

   273

                if(index < HMI_ITEM_COUNT)

   274

                {

   275

                    hmi_tree_item_t *dsc = &hmi_tree_item[index];

   276

                    void *real_value_p = NULL;

   277

                    char flags = 0;

   278

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

   279

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

   280

                    uint32_t sz = __get_type_enum_size(dsc->type);

   281

   283

                    {

   284

                        // rescheduling spinlock until free

   285

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

   286

   287

                        memcpy(dst_p, valptr, sz);

   288

                        dsc->rstate = buf_set;

   289

   290

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

   291

                        progress = sz + sizeof(uint32_t) /* index */;

   292

                    }

   293

                    else return -EINVAL;

   294

                }

   295

                else return -EINVAL;

   296

            }

   297

            break;

   298

   299

            case reset:

   300

            {

   301

                progress = 0;

   302

                traverse_hmi_tree(reset_iterator);

   303

            }

   304

            break;

   305

   306

            case subscribe:

   307

            {

   308

                uint32_t index = *(uint32_t*)(cursor);

   309

                uint16_t refresh_period_ms = *(uint32_t*)(cursor + sizeof(uint32_t));

   310

   311

                if(index < HMI_ITEM_COUNT)

   312

                {

   313

                    hmi_tree_item_t *dsc = &hmi_tree_item[index];

   315

                }

   316

                else return -EINVAL;

   317

   318

                progress = sizeof(uint32_t) /* index */ + 

   319

                           sizeof(uint16_t) /* refresh period */;

   320

            }

   321

            break;

   322

   323

            case unsubscribe:

   324

            {

   327

                if(index < HMI_ITEM_COUNT)

   328

                {

   329

                    hmi_tree_item_t *dsc = &hmi_tree_item[index];

   330

                    reset_iterator(index, dsc);

   331

                }

   332

                else return -EINVAL;

   333

   334

                progress = sizeof(uint32_t) /* index */;

   335

            }

   336

            break;

   337

        }

   338

        cursor += progress;

   339

    }

   340

    return 0;

   341

}

   342