#include <pthread.h>

#include "iec_types_all.h"

#include "POUS.h"

#include "config.h"

#include "beremiz.h"

#define DEFAULT_REFRESH_PERIOD_MS 100

#define HMI_BUFFER_SIZE %(buffer_size)d

/* PLC reads from that buffer */

static char rbuf[HMI_BUFFER_SIZE];

/* PLC writes to that buffer */

static char wbuf[HMI_BUFFER_SIZE];

%(extern_variables_declarations)s

#define ticktime_ns %(PLC_ticktime)d

uint16_t ticktime_ms = (ticktime_ns>1000000)?

ticktime_ns/1000000:

1;

typedef enum {

buf_free = 0,

buf_set,

buf_tosend

} buf_state_t;

int global_write_dirty = 0;

typedef struct {

void *ptr;

__IEC_types_enum type;

uint32_t buf_index;

/* publish/write/send */

long wlock;

/* zero means not subscribed */

uint16_t refresh_period_ms;

uint16_t age_ms;

buf_state_t wstate;

/* retrieve/read/recv */

long rlock;

buf_state_t rstate;

} hmi_tree_item_t;

static hmi_tree_item_t hmi_tree_item[] = {

%(variable_decl_array)s

};

typedef void(*hmi_tree_iterator)(hmi_tree_item_t*);

void traverse_hmi_tree(hmi_tree_iterator fp)

{

unsigned int i;

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

hmi_tree_item_t *dsc = &hmi_tree_item[i];

if(dsc->type != UNKNOWN_ENUM)

(*fp)(dsc);

}

}

#define __Unpack_desc_type hmi_tree_item_t

%(var_access_code)s

void write_iterator(hmi_tree_item_t *dsc)

{

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

void *real_value_p = NULL;

char flags = 0;

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

/* Try take lock */

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

if(was_locked) {

/* was locked. give up*/

return;

}

if(dsc->wstate == buf_set){

/* if being subscribed */

if(dsc->refresh_period_ms){

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

dsc->age_ms += ticktime_ms;

}else{

dsc->wstate = buf_tosend;

}

}

}

/* if new value differs from previous one */

if(memcmp(dest_p, visible_value_p, __get_type_enum_size(dsc->type)) != 0){

/* copy and flag as set */

memcpy(dest_p, visible_value_p, __get_type_enum_size(dsc->type));

if(dsc->wstate == buf_free) {

dsc->wstate = buf_set;

dsc->age_ms = 0;

}

global_write_dirty = 1;

}

/* unlock - use AtomicComparExchange to have memory barrier */

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

}

struct timespec sending_now;

struct timespec next_sending;

void send_iterator(hmi_tree_item_t *dsc)

{

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

// check for variable being modified

if(dsc->wstate == buf_tosend){

// send

// TODO call the python callback

dsc->wstate = buf_free;

}

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

}

void read_iterator(hmi_tree_item_t *dsc)

{

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

void *real_value_p = NULL;

char flags = 0;

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

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

}

int __init_svghmi()

{

bzero(rbuf,sizeof(rbuf));

bzero(wbuf,sizeof(wbuf));

// TODO - sending pthread condition variable

return 0;

}

void __cleanup_svghmi()

{

}

void __retrieve_svghmi()

{

traverse_hmi_tree(read_iterator);

}

void __publish_svghmi()

{

global_write_dirty = 0;

traverse_hmi_tree(write_iterator);

if(global_write_dirty) {

// TODO : set condition variable to wakeup sending collector

}

}

void* collect_updates_to_send(void* args){

// TODO : get callback from args

// TODO : wait for

// - condition variable

// TODO add arg to traverse_hmi_tree to pass callback

traverse_hmi_tree(send_iterator);

}