static int
scroll(void *data)
{
app_t *app = data;
struct timeval dif;
unsigned long current_ms;
double amount;
int y;
gettimeofday(&app->scroll.last, NULL);
timersub(&app->scroll.last, &app->scroll.start, &dif);
current_ms = tv2ms(&dif);
if (current_ms >= app->scroll.delay_ms) {
scroll_ended(app);
app->scroll.anim = NULL;
return 0;
}
amount = app->scroll.dir * ((double)current_ms / app->scroll.delay_ms);
y = app->item_height * amount;
evas_object_move(app->e_box, app->box_x, app->box_y + y);
return 1;
}
// TODO need esc after crc8_xor
int gp_send(cmd_send_t* cmd) {
size_t cmd_len=cmd->data_len;
// gp_cfg.gp_timeout=cmd->set_timeout;
evutil_timerclear(&gp_cfg.timeout);
// gp_cfg.timeout.tv_usec = cmd->set_timeout * 1000;
gp_cfg.timeout.tv_usec = gp_cfg.gp_timeout * 1000;
gp_cfg.polling = cmd->polling;
// gp_cfg.last_target = cmd->target_n;
send_mess.is_expected=1;
send_mess.bank = cmd->bank;
send_mess.target = cmd->target_n;
if( cmd->ev_handler != 0 ) {
send_mess.ev_handler=cmd->ev_handler;
} else if( cmd->queue != AD_Q_SHORT ) {
send_mess.ev_handler=0; // deleting handler
}
memset(&send_mess.buf, 0, sizeof(send_mess.buf));
send_mess.fl_begin = GP_INIT;
send_mess.id_ctrl = GP_CTRL;
send_mess.dev = send_mess.dst = cmd->dst;
send_mess.cmd_n = cmd->cmd_n;
cmd->cmd_buff[cmd_len]=crc8_xor(&cmd->cmd_n, cmd_len + 1);
// fprintf(stderr, "Buffer size: %d bytes, crc8: 0x%02x\n", cmd_len, cmd->cmd_buff[cmd_len]);
size_t len_esc=memcpy_esc((uint8_t*)&send_mess.dst, &cmd->dst,cmd_len+3)+3;
// fprintf(stderr, "Final size: %d bytes\n", len_esc);
send_mess.buf[len_esc-1]=GP_END;
// saved len and fd
send_mess.len=len_esc;
struct timeval tv;
gettimeofday(&tv,NULL);
// devices[send_mess.dev].last_sent=send_mess.sent_time=(tv.tv_sec%100000)* 1000 + tv.tv_usec/1000;
devices[send_mess.dev].last_sent=send_mess.sent_time=tv2ms(tv);
return gp_resend();
}
unsigned long int gettimeofday_ms()
{
struct timeval curr;
gettimeofday(&curr, NULL);
return tv2ms(&curr);
}
uint64_t gettimeofday_ms() {
struct timeval curr;
gettimeofday(&curr, NULL);
return tv2ms(&curr);
}
int gp_send_idle() {
static int gp_dst=0;
int activ=0;
do {
gp_dst++;
if( gp_dst > gp_cfg.max_dev_n ) { gp_dst=0; return 0; }
// fprintf(stderr, "Check gp_send_idle for %d (%d)\n",gp_dst,devices[gp_dst].timeout_count );
if(devices[gp_dst].timeout_count > gp_cfg.max_timeout_count) {
if( devices[gp_dst].activ > 0)
// if ( gp_dst == 5 )
{
fprintf(stderr, "Disabled dev %d (%d)\n", gp_dst, devices[gp_dst].timeout_count);
syslog(LOG_ERR, "Disabled dev %d (%d)\n", gp_dst, devices[gp_dst].timeout_count);
}
devices[gp_dst].activ=activ=0;
continue;
}
activ=1;
} while( activ == 0 );
// if ( gp_dst == 5 )
// fprintf(stderr, "Run gp_send_idle for %d (%d)\n",gp_dst,devices[gp_dst].timeout_count );
/* cmd_send_t z = {
.cmd_n = 0x06,
.set_timeout = 50,
.polling = 1,
.data_len = 0
};*/
//return 0;
// return ad_get_cid(AD_Q_SHORT, gp_dst, &cb_get_poll_result);
cmd_send_t z = {
.queue = AD_Q_SHORT,
.ev_handler = &cb_get_poll_result,
.target_n = AD_TARGET_GET_CID,
.cmd_n = 0x04,
.set_timeout = 150,
.polling = 1,
.data_len = 5,
.cmd_buff = { 0x00, 0xD0, 6, 0x00, 0x0C }
};
z.dst=gp_dst;
return gp_send(&z);
}
#pragma pack(push,1)
#pragma pack(pop)
//void gp_receiv(uint8_t* in, int nread) {
// short event=4;
int mydev=-1;
int err=0;
void gp_receiv(int fd, short event, void *arg) {
int nread=0;
// int last=0;
struct timeval tv;
gettimeofday(&tv,NULL);
uint32_t current_time=tv2ms(tv);
uint32_t expect_time=tv2ms(gp_cfg.timeout);
uint32_t delta = current_time - send_mess.sent_time;
uint32_t delta2 = current_time - receiv_mess.last_read;
/* if (send_mess.dev == 1 )
fprintf(stderr, "Got event (%d): 0x%X, %u.%06u (%u ms), sent time %u ms, current timeout: %u ms, delta: %u ms (%u ms)\n",
send_mess.dev,
event,
tv.tv_sec,tv.tv_usec,
current_time,
send_mess.sent_time,
expect_time,
delta, delta2
);*/
// char buf[PORT_READ_BUF_LENGTH];
// memset(buf, 0, sizeof(buf));
// if ( event_del(&send_mess.ev_timeout) < 0) syslog(LOG_ERR, "event_del (send_mess.ev_timeout): %m");
// event_set(&evsocket, sockfd, EV_READ|EV_PERSIST, socket_read, (void*)&evsocket);
// if ( event_del(&gp_cfg.evport) < 0) syslog(LOG_ERR, "event_del (send_mess.ev_timeout): %m");
/* if( (event & EV_WRITE) != 0 ) {
// gp_put_cmd();
return;
}*/
/* evutil_timerclear(&gp_cfg.timeout);
gp_cfg.timeout.tv_usec = gp_cfg.gp_timeout * 1000;
if ( event_add(&gp_cfg.evport, &gp_cfg.timeout) < 0) syslog(LOG_ERR, "event_add.send_mess.ev_timeout setup: %m");*/
if( (event & EV_READ) == 0 ) {
gp_reconnect(0);
// HACK - we check real timeout, not timer
// if( current_time >= expect_time ) {
// } else if(gp_cfg.timeout.tv_sec > 0) {
/* if ( send_mess.dev == 5 )
fprintf(stderr, "dev=%d, delta by sent = %d, delta by read = %d, count = %d\n",
send_mess.dev,delta, delta2, devices[send_mess.dev].timeout_count );*/
if( delta >= gp_cfg.gp_timeout) {
if( send_mess.is_expected > 0 ) {
send_mess.is_expected=0;
devices[send_mess.dev].timeout_count++;
// if ( send_mess.dev == 1 ) fprintf(stderr, "inc %d dev=%d\n", devices[send_mess.dev].timeout_count, send_mess.dev);
if( gp_cfg.polling == 0 ) {
// if( send_mess.dev == 1 ) {
// send_mess.target=0;
uint32_t delta3=current_time - devices[send_mess.dev].last_read;
fprintf(stderr, "Timeout (%d) for read for %d (cmd=%d, delta=%u)\n", devices[send_mess.dev].timeout_count,
send_mess.dev, send_mess.target, delta3);
syslog(LOG_ERR, "Timeout (%d) for read for %d (cmd=%d, delta=%u)", devices[send_mess.dev].timeout_count,
send_mess.dev, send_mess.target, delta3);
}
}
}
// if( current_time >= expect_time + gp_cfg.gp_timeout) {
// if( current_time - receiv_mess.last_read > gp_cfg.gp_timeout) {
if( delta >= gp_cfg.gp_timeout) {
// /* if ( send_mess.dev == 5 )
// fprintf(stderr, "Runed gp_put_cmd!\n");*/
if( gp_put_cmd() > 0 || gp_send_idle() > 0) return;
}
evutil_timerclear(&gp_cfg.timeout);
gp_cfg.timeout.tv_usec = gp_cfg.gp_timeout * 1000;
if ( event_add(&gp_cfg.evport, &gp_cfg.timeout) < 0) syslog(LOG_ERR, "event_add.send_mess.ev_timeout setup: %m");
return;
}
// HACK Read (EV_READ)
evutil_timerclear(&gp_cfg.timeout);
gp_cfg.timeout.tv_usec = gp_cfg.gp_timeout * 1000;
if ( event_add(&gp_cfg.evport, &gp_cfg.timeout) < 0) syslog(LOG_ERR, "event_add.send_mess.ev_timeout setup: %m");
// fprintf(stderr, "Set last read %lu \n",current_time);
devices[send_mess.dev].last_read=receiv_mess.last_read=current_time;
// gp_cfg.last_dev=send_mess.dev;
send_mess.is_expected=0;
// TODO after check crc
if( gp_cfg.polling == 1 && devices[send_mess.dev].activ==0) {
syslog(LOG_ERR,"Found dev: '%d'\n",send_mess.dev);
}
devices[send_mess.dev].activ=1;
devices[send_mess.dev].timeout_count=0;
if (devices[send_mess.dev].is_inited == 0) {
gp_dev_init(send_mess.dev);
}
// HACK
// mydev=send_mess.dst;
// First chunk of data.
if( receiv_buf_p == 0 ) {
receiv_buf_p = receiv_mess.buf;
receiv_mess.len=0;
}
nread = read(fd, receiv_buf_p, GP_PORT_READ_BUF_LENGTH - 1 - receiv_mess.len);
// if( debug >= 5 || (debug >= 4 && gp_cfg.polling == 0) || receiv_mess.src != 7) {
if( debug >= 9 || (debug >= 8 && gp_cfg.polling == 0) ) {
print_buff("port received: ", receiv_buf_p, nread);
}
// dprint(DL5, "read %d bytes, ev=%x\n", nread, event);
if (nread < 0) { /* EOF */
syslog(LOG_CRIT, "read: %m");
gp_close();
// daemon_exit(1); // never exit on error!
} else if (nread == 0) {
zprintf(1, "port unexpectedly closed\n");
ad_soft_reset(AD_Q_SHORT,send_mess.dev);
gp_close();
// gp_reconnect(0);
// if(err++ > 10 ) exit(102);
return;
} else if (nread > 0) {
// right trim buffer
receiv_buf_p[nread] = '\0';
if( receiv_mess.fl_begin != GP_INIT) {
syslog(LOG_ERR, "Begin flag not found");
gp_reconnect(0);
// gp_close();
return;
}
uint8_t* p=memchr(receiv_buf_p, GP_END,nread);
if ( p != 0 ) {
receiv_buf_p=0;
// *p='\0';
int l = p - &receiv_mess.id_ctrl; // buff. length for crc
// fprintf(stderr, "l = %d bytes\n", l);
// l = memcpy_unesc(receiv_mess.cmd_buff,receiv_mess.cmd_buff,l);
l = memcpy_unesc(&receiv_mess.id_ctrl,&receiv_mess.id_ctrl,l);
// fprintf(stderr, "l = %d bytes\n", l);
if ( crc8_xor(&receiv_mess.id_ctrl,l) > 0 ) {
int crc=crc8_xor(&receiv_mess.id_ctrl,l-1);
fprintf(stderr, "crc8 error for %d (cmd=%d, crc=x0%02x) \n", send_mess.dev, send_mess.target, crc);
syslog(LOG_ERR, "crc8 error for %d (cmd=%d, crc=x0%02x) \n", send_mess.dev, send_mess.target, crc);
if( debug < 9 )
print_buff("port received (crc error): ", receiv_mess.buf, nread+receiv_mess.len);
// exit(222);
return;
}
// Check error!!!
if( send_mess.dev != receiv_mess.src ) {
zprintf(2, "device error: got %d, expect %d\n", receiv_mess.src, send_mess.dev);
// exit(222);
return;
} else {
receiv_mess.dev=receiv_mess.src;
}
if( receiv_mess.cmd_n == GP_REPLY ) {
// syslog(LOG_ERR, "Got ask(0x%02X) for %d (cmd=%d)\n",receiv_mess.replay, send_mess.dev, send_mess.target);
if( receiv_mess.replay == GP_REPLY_ACK ) {
receiv_mess.cmd_n=receiv_mess.was_cmd_n;
// fprintf(stderr, "Got ACK for (0x%02X) \n", receiv_mess.was_cmd_n);
process_port_input(PROC_REPLY_ACK);
} else if ( receiv_mess.replay == GP_REPLY_NACK ) {
receiv_mess.cmd_n=receiv_mess.was_cmd_n;
zprintf(2, "Got NACK for (0x%02X) \n", receiv_mess.was_cmd_n);
// process_port_input(PROC_REPLY_NACK);
} else {
receiv_mess.cmd_n=receiv_mess.bad_cmd_n;
zprintf(2, "Got EEPROM/RTC error (%d)\n",receiv_mess.replay );
// process_port_input(PROC_REPLY_EEPROM_ERR);
}
} else {
receiv_mess.len=l-(3+1);
if( process_port_input(PROC_REPLY_ACK) > 0 ) return;
}
} else {
receiv_mess.len +=nread;
receiv_buf_p+=nread;
return;
}
// dprint(DL2, "port recvd: '%.*s'\n", nread, buf);
/* if(debug >= DL2) {
char buf2[PORT_READ_BUF_LENGTH];
char* p=strncpy(buf2,buf,PORT_READ_BUF_LENGTH);
while( (p=strchr(p,'\r')) > 0 ) *p='$';
p=buf2;
while( (p=strchr(buf2,'\n')) >0 ) *p='&';
dprint(DL2, "port recvd: '%s'\n", buf2);
}*/
}
// fprintf(stderr, "Sending new cmd\n");
gp_put_cmd();
// if ( gp_put_cmd() == 0 && event_add(&gp_cfg.evport, &gp_cfg.timeout) < 0)
// syslog(LOG_ERR, "event_add.send_mess.ev_timeout setup: %m");
// exit(0); f
// fprintf(stderr, "gp_receiv ok \n");
}
