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

    63

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

    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

        hmi_tree_item_t *dsc = &hmi_tree_item[i];

    69

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

    70

        if(res != 0){

    71

            return res;

    72

        }

    73

    }

    74

    return 0;

    75

}

    76

    77

#define __Unpack_desc_type hmi_tree_item_t

    78

    79

%(var_access_code)s

    80

    81

static int write_iterator(uint32_t index, hmi_tree_item_t *dsc)

    82

{

    83

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

    84

    {

    85

        if(dsc->wstate == buf_set){

    86

            /* if being subscribed */

    87

            if(dsc->refresh_period_ms){

    88

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

    89

                    dsc->age_ms += ticktime_ms;

    90

                }else{

    91

                    dsc->wstate = buf_tosend;

    92

                }

    93

            }

    94

        }

    95

    96

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

    97

        void *real_value_p = NULL;

    98

        char flags = 0;

    99

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

   100

   101

        /* if new value differs from previous one */

   102

        USINT sz = __get_type_enum_size(dsc->type);

   103

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

   104

            /* copy and flag as set */

   105

            memcpy(dest_p, visible_value_p, sz);

   106

            if(dsc->wstate == buf_free) {

   107

                dsc->wstate = buf_set;

   108

                dsc->age_ms = 0;

   109

            }

   110

            global_write_dirty = 1;

   111

        }

   112

   113

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

   114

    }

   115

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

   116

    return 0;

   117

}

   118

   119

static int send_iterator(uint32_t index, hmi_tree_item_t *dsc)

   120

{

   121

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

   122

   123

    if(dsc->wstate == buf_tosend)

   124

    {

   125

        uint32_t sz = __get_type_enum_size(dsc->type);

   126

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

   127

        {

   128

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

   129

            void *dst_p = &sbuf[sbufidx];

   130

            /* TODO : force into little endian */

   131

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

   132

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

   133

            dsc->wstate = buf_free;

   134

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

   135

        }

   136

        else

   137

        {

   138

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

   139

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

   140

            return EOVERFLOW; 

   141

        }

   142

    }

   143

   144

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

   145

    return 0; 

   146

}

   147

   148

static int read_iterator(uint32_t index, hmi_tree_item_t *dsc)

   149

{

   150

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

   151

    {

   152

        if(dsc->rstate == buf_set)

   153

        {

   154

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

   155

            void *real_value_p = NULL;

   156

            char flags = 0;

   157

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

   158

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

   159

            dsc->rstate = buf_free;

   160

        }

   161

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

   162

    }

   163

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

   164

    return 0;

   165

}

   166

   167

inline void update_refresh_period(hmi_tree_item_t *dsc, uint16_t refresh_period_ms)

   168

{

   169

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

   170

    dsc->refresh_period_ms = refresh_period_ms;

   171

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

   172

}

   173

   174

static int reset_iterator(uint32_t index, hmi_tree_item_t *dsc)

   175

{

   176

    update_refresh_period(dsc, 0);

   177

    return 0;

   178

}

   179

   180

static pthread_cond_t svghmi_send_WakeCond = PTHREAD_COND_INITIALIZER;

   181

static pthread_mutex_t svghmi_send_WakeCondLock = PTHREAD_MUTEX_INITIALIZER;

   182

   183

static int continue_collect;

   184

   185

int __init_svghmi()

   186

{

   187

    bzero(rbuf,sizeof(rbuf));

   188

    bzero(wbuf,sizeof(wbuf));

   189

    continue_collect = 1;

   190

   191

    return 0;

   192

}

   193

   194

void __cleanup_svghmi()

   195

{

   196

    pthread_mutex_lock(&svghmi_send_WakeCondLock);

   197

    continue_collect = 0;

   198

    pthread_cond_signal(&svghmi_send_WakeCond);

   199

    pthread_mutex_unlock(&svghmi_send_WakeCondLock);

   200

}

   201

   202

void __retrieve_svghmi()

   203

{

   204

    traverse_hmi_tree(read_iterator);

   205

}

   206

   207

void __publish_svghmi()

   208

{

   209

    global_write_dirty = 0;

   210

    traverse_hmi_tree(write_iterator);

   211

    if(global_write_dirty) {

   212

        pthread_cond_signal(&svghmi_send_WakeCond);

   213

    }

   214

}

   215

   216

/* PYTHON CALLS */

   217

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

   218

   219

    int do_collect;

   220

    pthread_mutex_lock(&svghmi_send_WakeCondLock);

   221

    do_collect = continue_collect;

   222

    if(do_collect)

   223

    {

   224

        pthread_cond_wait(&svghmi_send_WakeCond, &svghmi_send_WakeCondLock);

   225

        do_collect = continue_collect;

   226

    }

   227

    pthread_mutex_unlock(&svghmi_send_WakeCondLock);

   228

   229

    if(do_collect) {

   230

        int res;

   231

        sbufidx = HMI_HASH_SIZE;

   232

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

   233

        {

   234

            if(sbufidx > HMI_HASH_SIZE){

   235

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

   236

                *ptr = &sbuf[0];

   237

                *size = sbufidx;

   238

                return 0;

   239

            }

   240

            return ENODATA;

   241

        }

   242

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

   243

        return res;

   244

    }

   245

    else

   246

    {

   247

        return EINTR;

   248

    }

   249

}

   250

   251

typedef enum {

   252

    setval = 0,

   253

    reset = 1,

   254

    subscribe = 2

   255

} cmd_from_JS;

   256

   257

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

   258

    const uint8_t* cursor = ptr + HMI_HASH_SIZE;

   259

    const uint8_t* end = ptr + size;

   260

   261

   262

    /* match hmitree fingerprint */

   263

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

   264

    {

   265

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

   266

        return EINVAL;

   267

    }

   268

   269

    while(cursor < end)

   270

    {

   271

        uint32_t progress;

   272

        cmd_from_JS cmd = *(cursor++);

   273

        switch(cmd)

   274

        {

   275

            case setval:

   276

            {

   277

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

   278

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

   279

   280

                if(index < HMI_ITEM_COUNT)

   281

                {

   282

                    hmi_tree_item_t *dsc = &hmi_tree_item[index];

   283

                    void *real_value_p = NULL;

   284

                    char flags = 0;

   285

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

   286

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

   287

                    uint32_t sz = __get_type_enum_size(dsc->type);

   288

   289

                    if((valptr + sz) < end)

   290

                    {

   291

                        // rescheduling spinlock until free

   292

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

   293

   294

                        memcpy(dst_p, valptr, sz);

   295

                        dsc->rstate = buf_set;

   296

   297

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

   298

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

   299

                    }

   300

                    else 

   301

                    {

   302

                        return -EINVAL;

   303

                    }

   304

                }

   305

                else 

   306

                {

   307

                    return -EINVAL;

   308

                }

   309

            }

   310

            break;

   311

   312

            case reset:

   313

            {

   314

                progress = 0;

   315

                traverse_hmi_tree(reset_iterator);

   316

            }

   317

            break;

   318

   319

            case subscribe:

   320

            {

   321

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

   322

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

   323

   324

                if(index < HMI_ITEM_COUNT)

   325

                {

   326

                    hmi_tree_item_t *dsc = &hmi_tree_item[index];

   327

                    update_refresh_period(dsc, refresh_period_ms);

   328

                    printf("OK\n");

   329

                }

   330

                else 

   331

                {

   332

                    return -EINVAL;

   333

                }

   334

   335

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

   336

                           sizeof(uint16_t) /* refresh period */;

   337

            }

   338

            break;

   339

            default:

   340

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

   341

   342

        }

   343

        cursor += progress;

   344

    }

   345

    return 0;

   346

}

   347