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

#define MAX_CONNECTIONS %(max_connections)d

    13

    14

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

    15

    16

/* PLC reads from that buffer */

    17

static char rbuf[HMI_BUFFER_SIZE];

    18

    19

/* PLC writes to that buffer */

    20

static char wbuf[HMI_BUFFER_SIZE];

    21

    22

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

    23

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

    24

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

    25

static unsigned int sbufidx;

    26

    27

%(extern_variables_declarations)s

    28

    29

#define ticktime_ns %(PLC_ticktime)d

    30

static uint16_t ticktime_ms = (ticktime_ns>1000000)?

    31

                     ticktime_ns/1000000:

    32

                     1;

    33

    34

typedef enum {

    35

    buf_free = 0,

    36

    buf_new,

    37

    buf_set,

    38

    buf_tosend

    39

} buf_state_t;

    40

    41

static int global_write_dirty = 0;

    42

    43

typedef struct {

    44

    void *ptr;

    45

    __IEC_types_enum type;

    46

    uint32_t buf_index;

    47

    48

    /* publish/write/send */

    49

    long wlock;

    50

    buf_state_t wstate[MAX_CONNECTIONS];

    51

    52

    /* zero means not subscribed */

    53

    uint16_t refresh_period_ms[MAX_CONNECTIONS];

    54

    uint16_t age_ms[MAX_CONNECTIONS];

    55

    56

    /* retrieve/read/recv */

    57

    long rlock;

    58

    buf_state_t rstate;

    59

    60

} hmi_tree_item_t;

    61

    62

static hmi_tree_item_t hmi_tree_item[] = {

    63

%(variable_decl_array)s

    64

};

    65

    66

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

    67

static int traverse_hmi_tree(hmi_tree_iterator fp)

    68

{

    69

    unsigned int i;

    70

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

    71

        hmi_tree_item_t *dsc = &hmi_tree_item[i];

    72

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

    73

        if(res != 0){

    74

            return res;

    75

        }

    76

    }

    77

    return 0;

    78

}

    79

    80

#define __Unpack_desc_type hmi_tree_item_t

    81

    82

%(var_access_code)s

    83

    84

static int write_iterator(uint32_t index, hmi_tree_item_t *dsc)

    85

{

    86

    uint32_t session_index = 0;

    89

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

    90

        void *real_value_p = NULL;

    91

        char flags = 0;

    92

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

    93

        USINT sz = __get_type_enum_size(dsc->type);

    94

        if(__Is_a_string(dsc)){

    95

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

    96

        }

   130

            memcpy(dest_p, visible_value_p, sz);

   131

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

   132

    }

   133

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

   134

    return 0;

   135

}

   136

   137

static uint32_t send_session_index;

   138

static int send_iterator(uint32_t index, hmi_tree_item_t *dsc)

   139

{

   140

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

   141

   142

    if(dsc->wstate[send_session_index] == buf_tosend)

   143

    {

   144

        uint32_t sz = __get_type_enum_size(dsc->type);

   145

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

   146

        {

   147

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

   148

            void *dst_p = &sbuf[sbufidx];

   149

            if(__Is_a_string(dsc)){

   150

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

   151

            }

   152

            /* TODO : force into little endian */

   153

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

   154

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

   155

            dsc->wstate[send_session_index] = buf_free;

   156

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

   157

        }

   158

        else

   159

        {

   160

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

   161

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

   162

            return EOVERFLOW;

   163

        }

   164

    }

   165

   166

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

   167

    return 0;

   168

}

   169

   170

static int read_iterator(uint32_t index, hmi_tree_item_t *dsc)

   171

{

   172

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

   173

    {

   174

        if(dsc->rstate == buf_set)

   175

        {

   176

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

   177

            void *real_value_p = NULL;

   178

            char flags = 0;

   179

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

   180

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

   181

            dsc->rstate = buf_free;

   182

        }

   183

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

   184

    }

   185

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

   186

    return 0;

   187

}

   188

   189

void update_refresh_period(hmi_tree_item_t *dsc, uint32_t session_index, uint16_t refresh_period_ms)

   190

{

   191

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

   192

    if(refresh_period_ms) {

   193

        if(!dsc->refresh_period_ms[session_index])

   194

        {

   195

            dsc->wstate[session_index] = buf_new;

   196

        }

   197

    } else {

   198

        dsc->wstate[session_index] = buf_free;

   199

    }

   200

    dsc->refresh_period_ms[session_index] = refresh_period_ms;

   201

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

   202

}

   203

   204

static uint32_t reset_session_index;

   205

static int reset_iterator(uint32_t index, hmi_tree_item_t *dsc)

   206

{

   207

    update_refresh_period(dsc, reset_session_index, 0);

   208

    return 0;

   209

}

   210

   211

void SVGHMI_SuspendFromPythonThread(void);

   212

void SVGHMI_WakeupFromRTThread(void);

   213

   214

static int continue_collect;

   215

   216

int __init_svghmi()

   217

{

   218

    bzero(rbuf,sizeof(rbuf));

   219

    bzero(wbuf,sizeof(wbuf));

   220

   221

    continue_collect = 1;

   222

   223

    return 0;

   224

}

   225

   226

void __cleanup_svghmi()

   227

{

   228

    continue_collect = 0;

   229

    SVGHMI_WakeupFromRTThread();

   230

}

   231

   232

void __retrieve_svghmi()

   233

{

   234

    traverse_hmi_tree(read_iterator);

   235

}

   236

   237

void __publish_svghmi()

   238

{

   239

    global_write_dirty = 0;

   240

    traverse_hmi_tree(write_iterator);

   241

    if(global_write_dirty) {

   242

        SVGHMI_WakeupFromRTThread();

   243

    }

   244

}

   245

   246

/* PYTHON CALLS */

   247

int svghmi_wait(void){

   248

   249

    SVGHMI_SuspendFromPythonThread();

   250

}

   251

   252

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

   253

   254

    if(continue_collect) {

   255

        int res;

   256

        sbufidx = HMI_HASH_SIZE;

   257

        send_session_index = session_index;

   258

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

   259

        {

   260

            if(sbufidx > HMI_HASH_SIZE){

   261

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

   262

                *ptr = &sbuf[0];

   263

                *size = sbufidx;

   264

                return 0;

   265

            }

   266

            return ENODATA;

   267

        }

   268

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

   269

        return res;

   270

    }

   271

    else

   272

    {

   273

        return EINTR;

   274

    }

   275

}

   276

   277

typedef enum {

   278

    setval = 0,

   279

    reset = 1,

   280

    subscribe = 2

   281

} cmd_from_JS;

   282

   283

int svghmi_reset(uint32_t session_index){

   284

    reset_session_index = session_index;

   285

    traverse_hmi_tree(reset_iterator);

   286

    return 1;

   287

}

   288

   289

// Returns :

   290

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

   291

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

   292

    const uint8_t* cursor = ptr + HMI_HASH_SIZE;

   293

    const uint8_t* end = ptr + size;

   294

   295

    int was_hearbeat = 0;

   296

   297

    /* match hmitree fingerprint */

   298

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

   299

    {

   300

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

   301

        return -EINVAL;

   302

    }

   303

   304

    while(cursor < end)

   305

    {

   306

        uint32_t progress;

   307

        cmd_from_JS cmd = *(cursor++);

   308

        switch(cmd)

   309

        {

   310

            case setval:

   311

            {

   312

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

   313

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

   314

   315

                if(index == heartbeat_index)

   316

                    was_hearbeat = 1;

   317

   318

                if(index < HMI_ITEM_COUNT)

   319

                {

   320

                    hmi_tree_item_t *dsc = &hmi_tree_item[index];

   321

                    void *real_value_p = NULL;

   322

                    char flags = 0;

   323

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

   324

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

   325

                    uint32_t sz = __get_type_enum_size(dsc->type);

   326

   327

                    if(__Is_a_string(dsc)){

   328

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

   329

                    }

   330

   331

                    if((valptr + sz) <= end)

   332

                    {

   333

                        // rescheduling spinlock until free

   334

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

   335

   336

                        memcpy(dst_p, valptr, sz);

   337

                        dsc->rstate = buf_set;

   338

   339

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

   340

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

   341

                    }

   342

                    else

   343

                    {

   344

                        return -EINVAL;

   345

                    }

   346

                }

   347

                else

   348

                {

   349

                    return -EINVAL;

   350

                }

   351

            }

   352

            break;

   353

   354

            case reset:

   355

            {

   356

                progress = 0;

   357

                reset_session_index = session_index;

   358

                traverse_hmi_tree(reset_iterator);

   359

            }

   360

            break;

   361

   362

            case subscribe:

   363

            {

   364

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

   365

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

   366

   367

                if(index < HMI_ITEM_COUNT)

   368

                {

   369

                    hmi_tree_item_t *dsc = &hmi_tree_item[index];

   370

                    update_refresh_period(dsc, session_index, refresh_period_ms);

   371

                }

   372

                else

   373

                {

   374

                    return -EINVAL;

   375

                }

   376

   377

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

   378

                           sizeof(uint16_t) /* refresh period */;

   379

            }

   380

            break;

   381

            default:

   382

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

   383

   384

        }

   385

        cursor += progress;

   386

    }

   387

    return was_hearbeat;

   388

}

   389