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_new,

    35

    buf_set,

    36

    buf_tosend

    37

} buf_state_t;

    38

    39

static int global_write_dirty = 0;

    40

    41

typedef struct {

    42

    void *ptr;

    43

    __IEC_types_enum type;

    44

    uint32_t buf_index;

    45

    46

    /* publish/write/send */

    47

    long wlock;

    48

    buf_state_t wstate;

    49

    50

    /* zero means not subscribed */

    51

    uint16_t refresh_period_ms;

    52

    uint16_t age_ms;

    53

    54

    /* retrieve/read/recv */

    55

    long rlock;

    56

    buf_state_t rstate;

    57

    58

} hmi_tree_item_t;

    59

    60

static hmi_tree_item_t hmi_tree_item[] = {

    61

%(variable_decl_array)s

    62

};

    63

    64

typedef int(*hmi_tree_iterator)(uint32_t, hmi_tree_item_t*);

    65

static int traverse_hmi_tree(hmi_tree_iterator fp)

    66

{

    67

    unsigned int i;

    68

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

    69

        hmi_tree_item_t *dsc = &hmi_tree_item[i];

    70

        int res = (*fp)(i, dsc);

    71

        if(res != 0){

    72

            return res;

    73

        }

    74

    }

    75

    return 0;

    76

}

    77

    78

#define __Unpack_desc_type hmi_tree_item_t

    79

    80

%(var_access_code)s

    81

    82

static int write_iterator(uint32_t index, hmi_tree_item_t *dsc)

    83

{

    84

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

    85

    {

    86

        if(dsc->wstate == buf_set){

    87

            /* if being subscribed */

    88

            if(dsc->refresh_period_ms){

    89

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

    90

                    dsc->age_ms += ticktime_ms;

    91

                }else{

    92

                    dsc->wstate = buf_tosend;

    93

                    global_write_dirty = 1;

    94

                }

    95

            }

    96

        }

    97

    98

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

    99

        void *real_value_p = NULL;

   100

        char flags = 0;

   101

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

   102

   103

        /* if new value differs from previous one */

   104

        USINT sz = __get_type_enum_size(dsc->type);

   105

        if(dsc->wstate == buf_new || memcmp(dest_p, visible_value_p, sz) != 0){

   106

            /* copy and flag as set */

   107

            memcpy(dest_p, visible_value_p, sz);

   108

            if(dsc->wstate == buf_new || dsc->wstate == buf_free) {

   109

                if(dsc->wstate == buf_new || ticktime_ms > dsc->refresh_period_ms){

   110

                    dsc->wstate = buf_tosend;

   111

                    global_write_dirty = 1;

   112

                } else {

   113

                    dsc->wstate = buf_set;

   114

                }

   115

                dsc->age_ms = 0;

   116

            }

   117

        }

   118

   119

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

   120

    }

   121

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

   122

    return 0;

   123

}

   124

   125

static int send_iterator(uint32_t index, hmi_tree_item_t *dsc)

   126

{

   127

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

   128

   129

    if(dsc->wstate == buf_tosend)

   130

    {

   131

        uint32_t sz = __get_type_enum_size(dsc->type);

   132

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

   133

        {

   134

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

   135

            void *dst_p = &sbuf[sbufidx];

   136

            /* TODO : force into little endian */

   137

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

   138

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

   139

            dsc->wstate = buf_free;

   140

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

   141

        }

   142

        else

   143

        {

   144

            printf("BUG!!! %%d + %%ld + %%d >  %%ld \n", sbufidx, sizeof(uint32_t), sz,  sizeof(sbuf));

   145

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

   146

            return EOVERFLOW; 

   147

        }

   148

    }

   149

   150

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

   151

    return 0; 

   152

}

   153

   154

static int read_iterator(uint32_t index, hmi_tree_item_t *dsc)

   155

{

   156

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

   157

    {

   158

        if(dsc->rstate == buf_set)

   159

        {

   160

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

   161

            void *real_value_p = NULL;

   162

            char flags = 0;

   163

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

   164

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

   165

            dsc->rstate = buf_free;

   166

        }

   167

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

   168

    }

   169

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

   170

    return 0;

   171

}

   172

   173

void update_refresh_period(hmi_tree_item_t *dsc, uint16_t refresh_period_ms)

   174

{

   175

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

   176

    dsc->refresh_period_ms = refresh_period_ms;

   177

    if(refresh_period_ms) {

   178

        /* TODO : maybe only if was null before for optimization */

   179

        dsc->wstate = buf_new;

   180

    } else {

   181

        dsc->wstate = buf_free;

   182

    }

   183

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

   184

}

   185

   186

static int reset_iterator(uint32_t index, hmi_tree_item_t *dsc)

   187

{

   188

    update_refresh_period(dsc, 0);

   189

    return 0;

   190

}

   191

   194

   195

static int continue_collect;

   196

   197

int __init_svghmi()

   198

{

   199

    bzero(rbuf,sizeof(rbuf));

   200

    bzero(wbuf,sizeof(wbuf));

   201

   202

    continue_collect = 1;

   203

   204

    return 0;

   205

}

   206

   207

void __cleanup_svghmi()

   208

{

   209

    continue_collect = 0;

   211

}

   212

   213

void __retrieve_svghmi()

   214

{

   215

    traverse_hmi_tree(read_iterator);

   216

}

   217

   218

void __publish_svghmi()

   219

{

   220

    global_write_dirty = 0;

   221

    traverse_hmi_tree(write_iterator);

   222

    if(global_write_dirty) {

   224

    }

   225

}

   226

   227

/* PYTHON CALLS */

   228

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

   229

   233

        int res;

   234

        sbufidx = HMI_HASH_SIZE;

   235

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

   236

        {

   237

            if(sbufidx > HMI_HASH_SIZE){

   238

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

   239

                *ptr = &sbuf[0];

   240

                *size = sbufidx;

   241

                return 0;

   242

            }

   243

            return ENODATA;

   244

        }

   245

        // printf("collected BAD result %%d\n", res);

   246

        return res;

   247

    }

   248

    else

   249

    {

   250

        return EINTR;

   251

    }

   252

}

   253

   254

typedef enum {

   255

    setval = 0,

   256

    reset = 1,

   257

    subscribe = 2

   258

} cmd_from_JS;

   259

   260

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

   261

    const uint8_t* cursor = ptr + HMI_HASH_SIZE;

   262

    const uint8_t* end = ptr + size;

   263

   264

   265

    /* match hmitree fingerprint */

   266

    if(size <= HMI_HASH_SIZE || memcmp(ptr, hmi_hash, HMI_HASH_SIZE) != 0)

   267

    {

   268

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

   269

        return EINVAL;

   270

    }

   271

   272

    while(cursor < end)

   273

    {

   274

        uint32_t progress;

   275

        cmd_from_JS cmd = *(cursor++);

   276

        switch(cmd)

   277

        {

   278

            case setval:

   279

            {

   280

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

   281

                uint8_t const *valptr = cursor + sizeof(uint32_t);

   282

   283

                if(index < HMI_ITEM_COUNT)

   284

                {

   285

                    hmi_tree_item_t *dsc = &hmi_tree_item[index];

   286

                    void *real_value_p = NULL;

   287

                    char flags = 0;

   288

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

   289

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

   290

                    uint32_t sz = __get_type_enum_size(dsc->type);

   291

   292

                    if((valptr + sz) <= end)

   293

                    {

   294

                        // rescheduling spinlock until free

   295

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

   296

   297

                        memcpy(dst_p, valptr, sz);

   298

                        dsc->rstate = buf_set;

   299

   300

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

   301

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

   302

                    }

   303

                    else 

   304

                    {

   305

                        return -EINVAL;

   306

                    }

   307

                }

   308

                else 

   309

                {

   310

                    return -EINVAL;

   311

                }

   312

            }

   313

            break;

   314

   315

            case reset:

   316

            {

   317

                progress = 0;

   318

                traverse_hmi_tree(reset_iterator);

   319

            }

   320

            break;

   321

   322

            case subscribe:

   323

            {

   324

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

   325

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

   326

   327

                if(index < HMI_ITEM_COUNT)

   328

                {

   329

                    hmi_tree_item_t *dsc = &hmi_tree_item[index];

   330

                    update_refresh_period(dsc, refresh_period_ms);

   331

                }

   332

                else 

   333

                {

   334

                    return -EINVAL;

   335

                }

   336

   337

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

   338

                           sizeof(uint16_t) /* refresh period */;

   339

            }

   340

            break;

   341

            default:

   342

                printf("svghmi_recv_dispatch unknown %%d\n",cmd);

   343

   344

        }

   345

        cursor += progress;

   346

    }

   347

    return 0;

   348

}

   349