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;

    87     int value_changed = 0;

    88     if(AtomicCompareExchange(&dsc->wlock, 0, 1) == 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         }

    97         while(session_index < MAX_CONNECTIONS) {

    98             if(dsc->wstate[session_index] == buf_set){

    99                 /* if being subscribed */

   100                 if(dsc->refresh_period_ms[session_index]){

   101                     if(dsc->age_ms[session_index] + ticktime_ms < dsc->refresh_period_ms[session_index]){

   102                         dsc->age_ms[session_index] += ticktime_ms;

   103                     }else{

   104                         dsc->wstate[session_index] = buf_tosend;

   105                         global_write_dirty = 1;

   106                     }

   107                 }

   108             }

   109 

   110             if(dsc->wstate[session_index] == buf_new /* just subscribed 

   111                or already subscribed having value change */

   112                || (dsc->refresh_period_ms[session_index] > 0 

   113                    && (value_changed || (value_changed=memcmp(dest_p, visible_value_p, sz))) != 0)){

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

   115                 if(dsc->wstate[session_index] != buf_set && dsc->wstate[session_index] != buf_tosend) {

   116                     if(dsc->wstate[session_index] == buf_new || ticktime_ms > dsc->refresh_period_ms[session_index]){

   117                         dsc->wstate[session_index] = buf_tosend;

   118                         global_write_dirty = 1;

   119                     } else {

   120                         dsc->wstate[session_index] = buf_set;

   121                     }

   122                     dsc->age_ms[session_index] = 0;

   123                 }

   124             }

   125 

   126             session_index++;

   127         }

   128         /* copy value if changed (and subscribed) */

   129         if(value_changed)

   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))

   141         nRT_reschedule();

   142 

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

   144     {

   145         uint32_t sz = __get_type_enum_size(dsc->type);

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

   147         {

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

   149             void *dst_p = &sbuf[sbufidx];

   150             if(__Is_a_string(dsc)){

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

   152             }

   153             /* TODO : force into little endian */

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

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

   156             dsc->wstate[send_session_index] = buf_free;

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

   158         }

   159         else

   160         {

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

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

   163             return EOVERFLOW;

   164         }

   165     }

   166 

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

   168     return 0;

   169 }

   170 

   171 static int read_iterator(uint32_t index, hmi_tree_item_t *dsc)

   172 {

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

   174     {

   175         if(dsc->rstate == buf_set)

   176         {

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

   178             void *real_value_p = NULL;

   179             char flags = 0;

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

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

   182             dsc->rstate = buf_free;

   183         }

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

   185     }

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

   187     return 0;

   188 }

   189 

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

   191 {

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

   193         nRT_reschedule();

   194 

   195     if(refresh_period_ms) {

   196         if(!dsc->refresh_period_ms[session_index])

   197         {

   198             dsc->wstate[session_index] = buf_new;

   199         }

   200     } else {

   201         dsc->wstate[session_index] = buf_free;

   202     }

   203     dsc->refresh_period_ms[session_index] = refresh_period_ms;

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

   205 }

   206 

   207 static uint32_t reset_session_index;

   208 static int reset_iterator(uint32_t index, hmi_tree_item_t *dsc)

   209 {

   210     update_refresh_period(dsc, reset_session_index, 0);

   211     return 0;

   212 }

   213 

   214 static void *svghmi_handle;

   215 

   216 void SVGHMI_SuspendFromPythonThread(void)

   217 {

   218     wait_RT_to_nRT_signal(svghmi_handle);

   219 }

   220 

   221 void SVGHMI_WakeupFromRTThread(void)

   222 {

   223     unblock_RT_to_nRT_signal(svghmi_handle);

   224 }

   225 

   226 int svghmi_continue_collect;

   227 

   228 int __init_svghmi()

   229 {

   230     memset(rbuf,0,sizeof(rbuf));

   231     memset(wbuf,0,sizeof(wbuf));

   232 

   233     svghmi_continue_collect = 1;

   234 

   235     /* create svghmi_pipe */

   236     svghmi_handle = create_RT_to_nRT_signal("SVGHMI_pipe");

   237 

   238     if(!svghmi_handle) 

   239         return 1;

   240 

   241     return 0;

   242 }

   243 

   244 void __cleanup_svghmi()

   245 {

   246     svghmi_continue_collect = 0;

   247     SVGHMI_WakeupFromRTThread();

   248     delete_RT_to_nRT_signal(svghmi_handle);

   249 }

   250 

   251 void __retrieve_svghmi()

   252 {

   253     traverse_hmi_tree(read_iterator);

   254 }

   255 

   256 void __publish_svghmi()

   257 {

   258     global_write_dirty = 0;

   259     traverse_hmi_tree(write_iterator);

   260     if(global_write_dirty) {

   261         SVGHMI_WakeupFromRTThread();

   262     }

   263 }

   264 

   265 /* PYTHON CALLS */

   266 int svghmi_wait(void){

   267 

   268     SVGHMI_SuspendFromPythonThread();

   269 }

   270 

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

   272 

   273     if(svghmi_continue_collect) {

   274         int res;

   275         sbufidx = HMI_HASH_SIZE;

   276         send_session_index = session_index;

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

   278         {

   279             if(sbufidx > HMI_HASH_SIZE){

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

   281                 *ptr = &sbuf[0];

   282                 *size = sbufidx;

   283                 return 0;

   284             }

   285             return ENODATA;

   286         }

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

   288         return res;

   289     }

   290     else

   291     {

   292         return EINTR;

   293     }

   294 }

   295 

   296 typedef enum {

   297     setval = 0,

   298     reset = 1,

   299     subscribe = 2

   300 } cmd_from_JS;

   301 

   302 int svghmi_reset(uint32_t session_index){

   303     reset_session_index = session_index;

   304     traverse_hmi_tree(reset_iterator);

   305     return 1;

   306 }

   307 

   308 // Returns :

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

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

   311     const uint8_t* cursor = ptr + HMI_HASH_SIZE;

   312     const uint8_t* end = ptr + size;

   313 

   314     int was_hearbeat = 0;

   315 

   316     /* match hmitree fingerprint */

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

   318     {

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

   320         return -EINVAL;

   321     }

   322 

   323     while(cursor < end)

   324     {

   325         uint32_t progress;

   326         cmd_from_JS cmd = *(cursor++);

   327         switch(cmd)

   328         {

   329             case setval:

   330             {

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

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

   333 

   334                 if(index == heartbeat_index)

   335                     was_hearbeat = 1;

   336 

   337                 if(index < HMI_ITEM_COUNT)

   338                 {

   339                     hmi_tree_item_t *dsc = &hmi_tree_item[index];

   340                     void *real_value_p = NULL;

   341                     char flags = 0;

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

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

   344                     uint32_t sz = __get_type_enum_size(dsc->type);

   345 

   346                     if(__Is_a_string(dsc)){

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

   348                     }

   349 

   350                     if((valptr + sz) <= end)

   351                     {

   352                         // rescheduling spinlock until free

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

   354                             nRT_reschedule();

   355 

   356                         memcpy(dst_p, valptr, sz);

   357                         dsc->rstate = buf_set;

   358 

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

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

   361                     }

   362                     else

   363                     {

   364                         return -EINVAL;

   365                     }

   366                 }

   367                 else

   368                 {

   369                     return -EINVAL;

   370                 }

   371             }

   372             break;

   373 

   374             case reset:

   375             {

   376                 progress = 0;

   377                 reset_session_index = session_index;

   378                 traverse_hmi_tree(reset_iterator);

   379             }

   380             break;

   381 

   382             case subscribe:

   383             {

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

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

   386 

   387                 if(index < HMI_ITEM_COUNT)

   388                 {

   389                     hmi_tree_item_t *dsc = &hmi_tree_item[index];

   390                     update_refresh_period(dsc, session_index, refresh_period_ms);

   391                 }

   392                 else

   393                 {

   394                     return -EINVAL;

   395                 }

   396 

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

   398                            sizeof(uint16_t) /* refresh period */;

   399             }

   400             break;

   401             default:

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

   403 

   404         }

   405         cursor += progress;

   406     }

   407     return was_hearbeat;

   408 }

   409