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(__Is_a_string(dsc)){

   106

            sz = ((STRING*)visible_value_p)->len + 1;

   107

        }

   108

        if(dsc->wstate == buf_new /* just subscribed 

   109

           or already subscribed having value change */

   110

           || (dsc->refresh_period_ms > 0 && memcmp(dest_p, visible_value_p, sz) != 0)){

   111

            /* copy and flag as set */

   112

            memcpy(dest_p, visible_value_p, sz);

   113

            /* if not already marked/signaled, do it */

   114

            if(dsc->wstate != buf_set && dsc->wstate != buf_tosend) {

   115

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

   116

                    dsc->wstate = buf_tosend;

   117

                    global_write_dirty = 1;

   118

                } else {

   119

                    dsc->wstate = buf_set;

   120

                }

   121

                dsc->age_ms = 0;

   122

            }

   123

        }

   124

   125

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

   126

    }

   127

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

   128

    return 0;

   129

}

   130

   131

static int send_iterator(uint32_t index, hmi_tree_item_t *dsc)

   132

{

   133

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

   134

   135

    if(dsc->wstate == buf_tosend)

   136

    {

   137

        uint32_t sz = __get_type_enum_size(dsc->type);

   138

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

   139

        {

   140

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

   141

            void *dst_p = &sbuf[sbufidx];

   142

            if(__Is_a_string(dsc)){

   143

                sz = ((STRING*)src_p)->len + 1;

   144

            }

   145

            /* TODO : force into little endian */

   146

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

   147

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

   148

            dsc->wstate = buf_free;

   149

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

   150

        }

   151

        else

   152

        {

   153

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

   154

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

   155

            return EOVERFLOW;

   156

        }

   157

    }

   158

   159

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

   160

    return 0;

   161

}

   162

   163

static int read_iterator(uint32_t index, hmi_tree_item_t *dsc)

   164

{

   165

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

   166

    {

   167

        if(dsc->rstate == buf_set)

   168

        {

   169

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

   170

            void *real_value_p = NULL;

   171

            char flags = 0;

   172

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

   173

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

   174

            dsc->rstate = buf_free;

   175

        }

   176

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

   177

    }

   178

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

   179

    return 0;

   180

}

   181

   182

void update_refresh_period(hmi_tree_item_t *dsc, uint16_t refresh_period_ms)

   183

{

   184

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

   185

    if(refresh_period_ms) {

   186

        if(!dsc->refresh_period_ms)

   187

        {

   188

            dsc->wstate = buf_new;

   189

        }

   190

    } else {

   191

        dsc->wstate = buf_free;

   192

    }

   193

    dsc->refresh_period_ms = refresh_period_ms;

   194

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

   195

}

   196

   197

static int reset_iterator(uint32_t index, hmi_tree_item_t *dsc)

   198

{

   199

    update_refresh_period(dsc, 0);

   200

    return 0;

   201

}

   202

   203

void SVGHMI_SuspendFromPythonThread(void);

   204

void SVGHMI_WakeupFromRTThread(void);

   205

   206

static int continue_collect;

   207

   208

int __init_svghmi()

   209

{

   210

    bzero(rbuf,sizeof(rbuf));

   211

    bzero(wbuf,sizeof(wbuf));

   212

   213

    continue_collect = 1;

   214

   215

    return 0;

   216

}

   217

   218

void __cleanup_svghmi()

   219

{

   220

    continue_collect = 0;

   221

    SVGHMI_WakeupFromRTThread();

   222

}

   223

   224

void __retrieve_svghmi()

   225

{

   226

    traverse_hmi_tree(read_iterator);

   227

}

   228

   229

void __publish_svghmi()

   230

{

   231

    global_write_dirty = 0;

   232

    traverse_hmi_tree(write_iterator);

   233

    if(global_write_dirty) {

   234

        SVGHMI_WakeupFromRTThread();

   235

    }

   236

}

   237

   238

/* PYTHON CALLS */

   239

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

   240

   241

    SVGHMI_SuspendFromPythonThread();

   242

   243

    if(continue_collect) {

   244

        int res;

   245

        sbufidx = HMI_HASH_SIZE;

   246

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

   247

        {

   248

            if(sbufidx > HMI_HASH_SIZE){

   249

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

   250

                *ptr = &sbuf[0];

   251

                *size = sbufidx;

   252

                return 0;

   253

            }

   254

            return ENODATA;

   255

        }

   256

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

   257

        return res;

   258

    }

   259

    else

   260

    {

   261

        return EINTR;

   262

    }

   263

}

   264

   265

typedef enum {

   266

    setval = 0,

   267

    reset = 1,

   268

    subscribe = 2

   269

} cmd_from_JS;

   270

   271

// Returns :

   272

//   0 is OK, <0 is error, 1 is heartbeat

   273

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

   274

    const uint8_t* cursor = ptr + HMI_HASH_SIZE;

   275

    const uint8_t* end = ptr + size;

   276

   277

    int was_hearbeat = 0;

   278

   279

    /* match hmitree fingerprint */

   280

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

   281

    {

   282

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

   283

        return -EINVAL;

   284

    }

   285

   286

    while(cursor < end)

   287

    {

   288

        uint32_t progress;

   289

        cmd_from_JS cmd = *(cursor++);

   290

        switch(cmd)

   291

        {

   292

            case setval:

   293

            {

   294

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

   295

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

   296

   297

                if(index == heartbeat_index)

   298

                    was_hearbeat = 1;

   299

   300

                if(index < HMI_ITEM_COUNT)

   301

                {

   302

                    hmi_tree_item_t *dsc = &hmi_tree_item[index];

   303

                    void *real_value_p = NULL;

   304

                    char flags = 0;

   305

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

   306

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

   307

                    uint32_t sz = __get_type_enum_size(dsc->type);

   308

   309

                    if(__Is_a_string(dsc)){

   310

                        sz = ((STRING*)valptr)->len + 1;

   311

                    }

   312

   313

                    if((valptr + sz) <= end)

   314

                    {

   315

                        // rescheduling spinlock until free

   316

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

   317

   318

                        memcpy(dst_p, valptr, sz);

   319

                        dsc->rstate = buf_set;

   320

   321

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

   322

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

   323

                    }

   324

                    else

   325

                    {

   326

                        return -EINVAL;

   327

                    }

   328

                }

   329

                else

   330

                {

   331

                    return -EINVAL;

   332

                }

   333

            }

   334

            break;

   335

   336

            case reset:

   337

            {

   338

                progress = 0;

   339

                traverse_hmi_tree(reset_iterator);

   340

            }

   341

            break;

   342

   343

            case subscribe:

   344

            {

   345

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

   346

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

   347

   348

                if(index < HMI_ITEM_COUNT)

   349

                {

   350

                    hmi_tree_item_t *dsc = &hmi_tree_item[index];

   351

                    update_refresh_period(dsc, refresh_period_ms);

   352

                }

   353

                else

   354

                {

   355

                    return -EINVAL;

   356

                }

   357

   358

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

   359

                           sizeof(uint16_t) /* refresh period */;

   360

            }

   361

            break;

   362

            default:

   363

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

   364

   365

        }

   366

        cursor += progress;

   367

    }

   368

    return was_hearbeat;

   369

}

   370