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 || memcmp(dest_p, visible_value_p, sz) != 0){

   109

            /* copy and flag as set */

   110

            memcpy(dest_p, visible_value_p, sz);

   111

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

   112

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

   113

                    dsc->wstate = buf_tosend;

   114

                    global_write_dirty = 1;

   115

                } else {

   116

                    dsc->wstate = buf_set;

   117

                }

   118

                dsc->age_ms = 0;

   119

            }

   120

        }

   121

   122

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

   123

    }

   124

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

   125

    return 0;

   126

}

   127

   128

static int send_iterator(uint32_t index, hmi_tree_item_t *dsc)

   129

{

   130

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

   131

   132

    if(dsc->wstate == buf_tosend)

   133

    {

   134

        uint32_t sz = __get_type_enum_size(dsc->type);

   135

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

   136

        {

   137

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

   138

            void *dst_p = &sbuf[sbufidx];

   139

            if(__Is_a_string(dsc)){

   140

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

   141

            }

   142

            /* TODO : force into little endian */

   143

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

   144

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

   145

            dsc->wstate = buf_free;

   146

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

   147

        }

   148

        else

   149

        {

   150

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

   151

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

   152

            return EOVERFLOW; 

   153

        }

   154

    }

   155

   156

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

   157

    return 0; 

   158

}

   159

   160

static int read_iterator(uint32_t index, hmi_tree_item_t *dsc)

   161

{

   162

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

   163

    {

   164

        if(dsc->rstate == buf_set)

   165

        {

   166

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

   167

            void *real_value_p = NULL;

   168

            char flags = 0;

   169

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

   170

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

   171

            dsc->rstate = buf_free;

   172

        }

   173

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

   174

    }

   175

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

   176

    return 0;

   177

}

   178

   179

void update_refresh_period(hmi_tree_item_t *dsc, uint16_t refresh_period_ms)

   180

{

   181

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

   182

    dsc->refresh_period_ms = refresh_period_ms;

   183

    if(refresh_period_ms) {

   184

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

   185

        dsc->wstate = buf_new;

   186

    } else {

   187

        dsc->wstate = buf_free;

   188

    }

   189

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

   190

}

   191

   192

static int reset_iterator(uint32_t index, hmi_tree_item_t *dsc)

   193

{

   194

    update_refresh_period(dsc, 0);

   195

    return 0;

   196

}

   197

   198

void SVGHMI_SuspendFromPythonThread(void);

   199

void SVGHMI_WakeupFromRTThread(void);

   200

   201

static int continue_collect;

   202

   203

int __init_svghmi()

   204

{

   205

    bzero(rbuf,sizeof(rbuf));

   206

    bzero(wbuf,sizeof(wbuf));

   207

   208

    continue_collect = 1;

   209

   210

    return 0;

   211

}

   212

   213

void __cleanup_svghmi()

   214

{

   215

    continue_collect = 0;

   216

    SVGHMI_WakeupFromRTThread();

   217

}

   218

   219

void __retrieve_svghmi()

   220

{

   221

    traverse_hmi_tree(read_iterator);

   222

}

   223

   224

void __publish_svghmi()

   225

{

   226

    global_write_dirty = 0;

   227

    traverse_hmi_tree(write_iterator);

   228

    if(global_write_dirty) {

   229

        SVGHMI_WakeupFromRTThread();

   230

    }

   231

}

   232

   233

/* PYTHON CALLS */

   234

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

   235

   236

    SVGHMI_SuspendFromPythonThread();

   237

   238

    if(continue_collect) {

   239

        int res;

   240

        sbufidx = HMI_HASH_SIZE;

   241

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

   242

        {

   243

            if(sbufidx > HMI_HASH_SIZE){

   244

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

   245

                *ptr = &sbuf[0];

   246

                *size = sbufidx;

   247

                return 0;

   248

            }

   249

            return ENODATA;

   250

        }

   251

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

   252

        return res;

   253

    }

   254

    else

   255

    {

   256

        return EINTR;

   257

    }

   258

}

   259

   260

typedef enum {

   261

    setval = 0,

   262

    reset = 1,

   263

    subscribe = 2

   264

} cmd_from_JS;

   265

   266

// Returns :

   267

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

   268

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

   269

    const uint8_t* cursor = ptr + HMI_HASH_SIZE;

   270

    const uint8_t* end = ptr + size;

   271

   272

    int was_hearbeat = 0;

   273

   274

    /* match hmitree fingerprint */

   275

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

   276

    {

   277

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

   278

        return -EINVAL;

   279

    }

   280

   281

    while(cursor < end)

   282

    {

   283

        uint32_t progress;

   284

        cmd_from_JS cmd = *(cursor++);

   285

        switch(cmd)

   286

        {

   287

            case setval:

   288

            {

   289

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

   290

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

   291

   292

                if(index == heartbeat_index)

   293

                    was_hearbeat = 1;

   294

   295

                if(index < HMI_ITEM_COUNT)

   296

                {

   297

                    hmi_tree_item_t *dsc = &hmi_tree_item[index];

   298

                    void *real_value_p = NULL;

   299

                    char flags = 0;

   300

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

   301

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

   302

                    uint32_t sz = __get_type_enum_size(dsc->type);

   303

   304

                    if(__Is_a_string(dsc)){

   305

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

   306

                    }

   307

   308

                    if((valptr + sz) <= end)

   309

                    {

   310

                        // rescheduling spinlock until free

   311

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

   312

   313

                        memcpy(dst_p, valptr, sz);

   314

                        dsc->rstate = buf_set;

   315

   316

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

   317

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

   318

                    }

   319

                    else 

   320

                    {

   321

                        return -EINVAL;

   322

                    }

   323

                }

   324

                else 

   325

                {

   326

                    return -EINVAL;

   327

                }

   328

            }

   329

            break;

   330

   331

            case reset:

   332

            {

   333

                progress = 0;

   334

                traverse_hmi_tree(reset_iterator);

   335

            }

   336

            break;

   337

   338

            case subscribe:

   339

            {

   340

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

   341

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

   342

   343

                if(index < HMI_ITEM_COUNT)

   344

                {

   345

                    hmi_tree_item_t *dsc = &hmi_tree_item[index];

   346

                    update_refresh_period(dsc, refresh_period_ms);

   347

                }

   348

                else 

   349

                {

   350

                    return -EINVAL;

   351

                }

   352

   353

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

   354

                           sizeof(uint16_t) /* refresh period */;

   355

            }

   356

            break;

   357

            default:

   358

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

   359

   360

        }

   361

        cursor += progress;

   362

    }

   363

    return was_hearbeat;

   364

}

   365