svghmi/svghmi.c
branchsvghmi
changeset 2766 3f3b1b8ccba4
parent 2765 887aba5ef178
child 2767 302347f48193
equal deleted inserted replaced
2765:887aba5ef178 2766:3f3b1b8ccba4
    37         if(dsc->type != UNKNOWN_ENUM) 
    37         if(dsc->type != UNKNOWN_ENUM) 
    38             (*fp)(dsc);
    38             (*fp)(dsc);
    39     }
    39     }
    40 }
    40 }
    41 
    41 
    42 void read_iterator(hmi_tree_item_t *dsc){
    42 /* TODO : deduplicate that code with plc_debug.c */
    43     /* todo */
    43 
       
    44 #define __Unpack_case_t(TYPENAME) \
       
    45         case TYPENAME##_ENUM :\
       
    46             *flags = ((__IEC_##TYPENAME##_t *)varp)->flags;\
       
    47             forced_value_p = *real_value_p = &((__IEC_##TYPENAME##_t *)varp)->value;\
       
    48             break;
       
    49 
       
    50 #define __Unpack_case_p(TYPENAME)\
       
    51         case TYPENAME##_O_ENUM :\
       
    52             *flags = __IEC_OUTPUT_FLAG;\
       
    53         case TYPENAME##_P_ENUM :\
       
    54             *flags |= ((__IEC_##TYPENAME##_p *)varp)->flags;\
       
    55             *real_value_p = ((__IEC_##TYPENAME##_p *)varp)->value;\
       
    56             forced_value_p = &((__IEC_##TYPENAME##_p *)varp)->fvalue;\
       
    57             break;
       
    58 
       
    59 static void* UnpackVar(hmi_tree_item_t *dsc, void **real_value_p, char *flags)
       
    60 {
       
    61     void *varp = dsc->ptr;
       
    62     void *forced_value_p = NULL;
       
    63     *flags = 0;
       
    64     /* find data to copy*/
       
    65     switch(dsc->type){
       
    66         __ANY(__Unpack_case_t)
       
    67         __ANY(__Unpack_case_p)
       
    68     default:
       
    69         break;
       
    70     }
       
    71     if (*flags & __IEC_FORCE_FLAG)
       
    72         return forced_value_p;
       
    73     return *real_value_p;
    44 }
    74 }
    45 
    75 
    46 void write_iterator(hmi_tree_item_t *dsc){
    76 void write_iterator(hmi_tree_item_t *dsc)
    47     /* todo */
    77 {
       
    78     void *dest_p = &wbuf[dsc->buf_index];
       
    79     void *real_value_p = NULL;
       
    80     char flags = 0;
       
    81 
       
    82     void *visible_value_p = UnpackVar(dsc, &real_value_p, &flags);
       
    83 
       
    84     memcpy(dest_p, visible_value_p, __get_type_enum_size(dsc->type));
       
    85 }
       
    86 
       
    87 void read_iterator(hmi_tree_item_t *dsc)
       
    88 {
       
    89     void *src_p = &rbuf[dsc->buf_index];
       
    90     void *real_value_p = NULL;
       
    91     char flags = 0;
       
    92 
       
    93     void *visible_value_p = UnpackVar(dsc, &real_value_p, &flags);
       
    94 
       
    95     memcpy(visible_value_p, src_p, __get_type_enum_size(dsc->type));
    48 }
    96 }
    49 
    97 
    50 int __init_svghmi()
    98 int __init_svghmi()
    51 {
    99 {
    52     bzero(rbuf,sizeof(rbuf));
   100     bzero(rbuf,sizeof(rbuf));
    60 }
   108 }
    61 
   109 
    62 void __retrieve_svghmi()
   110 void __retrieve_svghmi()
    63 {
   111 {
    64     if(!pthread_mutex_lock(&rbuf_mutex)){
   112     if(!pthread_mutex_lock(&rbuf_mutex)){
       
   113         traverse_hmi_tree(read_iterator);
    65         pthread_mutex_unlock(&rbuf_mutex);
   114         pthread_mutex_unlock(&rbuf_mutex);
    66     }
   115     }
    67 }
   116 }
    68 
   117 
    69 void __publish_svghmi()
   118 void __publish_svghmi()