C++ clock_seconds函数代码示例

/*---------------------------------------------------------------------------*/
void
print_stats(void)
{
  PRINTA("S %d.%d clock %lu tx %lu rx %lu rtx %lu rrx %lu rexmit %lu acktx %lu noacktx %lu ackrx %lu timedout %lu badackrx %lu toolong %lu tooshort %lu badsynch %lu badcrc %lu contentiondrop %lu sendingdrop %lu lltx %lu llrx %lu\n",
	 rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
	 clock_seconds(),
	 rimestats.tx, rimestats.rx,
	 rimestats.reliabletx, rimestats.reliablerx,
	 rimestats.rexmit, rimestats.acktx, rimestats.noacktx,
	 rimestats.ackrx, rimestats.timedout, rimestats.badackrx,
	 rimestats.toolong, rimestats.tooshort,
	 rimestats.badsynch, rimestats.badcrc,
	 rimestats.contentiondrop, rimestats.sendingdrop,
	 rimestats.lltx, rimestats.llrx);
#if ENERGEST_CONF_ON
  PRINTA("E %d.%d clock %lu cpu %lu lpm %lu irq %lu gled %lu yled %lu rled %lu tx %lu listen %lu sensors %lu serial %lu\n",
	 rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
	 clock_seconds(),
	 energest_total_time[ENERGEST_TYPE_CPU].current,
	 energest_total_time[ENERGEST_TYPE_LPM].current,
	 energest_total_time[ENERGEST_TYPE_IRQ].current,
	 energest_total_time[ENERGEST_TYPE_LED_GREEN].current,
	 energest_total_time[ENERGEST_TYPE_LED_YELLOW].current,
	 energest_total_time[ENERGEST_TYPE_LED_RED].current,
	 energest_total_time[ENERGEST_TYPE_TRANSMIT].current,
	 energest_total_time[ENERGEST_TYPE_LISTEN].current,
	 energest_total_time[ENERGEST_TYPE_SENSORS].current,
	 energest_total_time[ENERGEST_TYPE_SERIAL].current);
#endif /* ENERGEST_CONF_ON */
}

/*---------------------------------------------------------------------------*/
PROCESS_THREAD(testcoffee_process, ev, data)
{
  int start;
  int result;

  PROCESS_BEGIN();

  start = clock_seconds();

  printf("Coffee test started\n");

  result = cfs_coffee_format();
  print_result("Formatting", result);

  result = coffee_test_basic();
  print_result("Basic operations", result);

  result = coffee_test_append();
  print_result("File append", result);

  result = coffee_test_modify();
  print_result("File modification", result);

  result = coffee_test_gc();
  print_result("Garbage collection", result);

  printf("Coffee test finished. Duration: %d seconds\n", 
         (int)(clock_seconds() - start));

  PROCESS_END();
}

/*---------------------------------------------------------------------------*/
static int
write_state(lwm2m_context_t *ctx, const uint8_t *inbuf, size_t insize,
            uint8_t *outbuf, size_t outsize)
{
  int value;
  size_t len;

  uint8_t idx = ctx->object_instance_index;
  if(idx >= LEDS_CONTROL_NUMBER) {
    return 0;
  }

  len = ctx->reader->read_boolean(ctx, inbuf, insize, &value);
  if(len > 0) {
    if(value) {
      if(!states[idx].is_on) {
        states[idx].is_on = 1;
        states[idx].last_on_time = clock_seconds();
#if PLATFORM_HAS_LEDS
        leds_on(1 << idx);
#endif /* PLATFORM_HAS_LEDS */
      }
    } else if(states[idx].is_on) {
      states[idx].total_on_time += clock_seconds() - states[idx].last_on_time;
      states[idx].is_on = 0;
#if PLATFORM_HAS_LEDS
      leds_off(1 << idx);
#endif /* PLATFORM_HAS_LEDS */
    }
  } else {
    PRINTF("IPSO leds control - ignored illegal write to on/off\n");
  }
  return len;
}

/*---------------------------------------------------------------------------*/
void
ipcp_task(u8_t *buffer)
{
   /* IPCP tx not up and hasn't timed out then lets see if we need to
   send a request */
   if(!(ipcp_state & IPCP_TX_UP) && !(ipcp_state & IPCP_TX_TIMEOUT)) {
      /* Check if we have a request pending */
      /*t=get_seconds()-ipcp_tx_time;*/
      #if 1//0//phlb modify
         if(TIMER_timeout(IPCP_TIMEOUT)) {
      #else
         if((clock_seconds() - prev_ipcp_seconds) > IPCP_TIMEOUT) {
            prev_ipcp_seconds = clock_seconds();
      #endif
            /**/
            ipcp_tx_confreq(buffer);
            /* Set timer */
            /*ipcp_tx_time=get_seconds();*/
            TIMER_set();
            /* Inc retry */
            /*ipcp_retry++;*/
            /*ppp_retry++;*/
            /*
            * Have we timed out? (combide the timers?)
            */
            if(ppp_retry > IPCP_RETRY_COUNT){
               ipcp_state &= IPCP_TX_TIMEOUT;
            }	
         }
   }
}

/*---------------------------------------------------------------------------*/
static void
doInterfaceActionsBeforeTick(void)
{
  if (!simRadioHWOn) {
    simInSize = 0;
    return;
  }
  if (simReceiving) {
    simLastSignalStrength = simSignalStrength;
    return;
  }

  if (simInSize > 0) {
    /* drop packets here */
    if (clock_seconds() >= failure_delay[simMoteID]) {
      if (!--packet_drop[simMoteID]) {
        dropped = 1;
        /* XXX */
        printf("radio_read: dropping the packet once @ %lu\n", clock_time());
        simInSize = 0;
        return;
      } else if (dropped) {
        if (packet_subsequent_drop[simMoteID]--) {
          /* XXX */
          printf("radio_read: subsequently dropping the packet @ %lu\n", clock_time());
          simInSize = 0;
          return;
        } else {
          dropped = 0;
        }
      }
    }
    process_poll(&cooja_radio_process);
  }
}

void p_stats(void)
{
  print_separator(stdout, "STATISTICS", TRUE);

  printf("\nFor domain size %d.\n\n",Domain_size);

  printf("Current CPU time: %.2f seconds ", clock_seconds(Mace4_clock));
  printf("(total CPU time: %.2f seconds).\n",user_seconds());
  printf("Ground clauses: seen=%u, kept=%u.\n",
	 Mstats.ground_clauses_seen, Mstats.ground_clauses_kept);
  printf("Selections=%u, assignments=%u, propagations=%u, current_models=%u.\n",
	 Mstats.selections, Mstats.assignments, Mstats.propagations, Mstats.current_models);
  printf("Rewrite_terms=%u, rewrite_bools=%u, indexes=%u.\n",
	 Mstats.rewrite_terms, Mstats.rewrite_bools, Mstats.indexes);
  printf("Rules_from_neg_clauses=%u, cross_offs=%d.\n",
	 Mstats.rules_from_neg, Mstats.cross_offs);
#if 0
  printf("Negative propagation:\n");
  printf("                 attempts      agone      egone\n");
  printf("Neg_elim        %10u %10u %10u\n",
	 Mstats.neg_elim_attempts, Mstats.neg_elim_agone, Mstats.neg_elim_egone);
  printf("Neg_assign      %10u %10u %10u\n",
	 Mstats.neg_assign_attempts, Mstats.neg_assign_agone, Mstats.neg_assign_egone);
  printf("Neg_near_elim   %10u %10u %10u\n",
	 Mstats.neg_near_elim_attempts, Mstats.neg_near_elim_agone, Mstats.neg_near_elim_egone);
  printf("Neg_near_assign %10u %10u %10u\n",
	 Mstats.neg_near_assign_attempts, Mstats.neg_near_assign_agone, Mstats.neg_near_assign_egone);
#endif
  print_separator(stdout, "end of statistics", TRUE);
}  /* p_stats */

/*---------------------------------------------------------------------------*/
unsigned long
getCurrTime(void)
{
  if(StartTime==0 && CurrTime==0)
    return 0;
  return (clock_seconds() - StartTime + CurrTime);
}

/**
 * the sensor node subscribed will send the data to the base station via the next hop according to the routing table
 */
void publish(struct runicast_conn *runicast){
    Ru_msg_list *ru_msg_list;
    Rt_table *chosen_route;
    if(list_length(runicast_list)>0){
        for(ru_msg_list = list_head(runicast_list);ru_msg_list!=NULL;){
            chosen_route = find_best_route();
            current_route = chosen_route;
            if(current_route!=NULL){
                packetbuf_copyfrom(&ru_msg_list->runicast_msg, sizeof(Runicast_msg));
                printf("[RU] @%[email protected]%u.%u->@%u.%u\n", clock_seconds(),rimeaddr_node_addr.u8[0],rimeaddr_node_addr.u8[1],
                       chosen_route->rt_entry.next_hop.u8[0],chosen_route->rt_entry.next_hop.u8[1]);
                runicast_send(runicast,&chosen_route->rt_entry.next_hop,MAX_RETRANSMISSIONS);
                packetbuf_clear();
                Ru_msg_list *to_remove;
                to_remove = ru_msg_list;
                ru_msg_list = ru_msg_list->next;
//                if(ru_send_success == true){
//                    list_remove(runicast_list,to_remove);
//                    memb_free(&runicast_list_memb,to_remove);
//                    printf("[DELET-RU-MSG]\n");
//                }
            }else{
                printf("[ERRO] current route is none");
            }


        }
    }
    remove_all_runicast_entry();
}

/* we want this to do something a while, then go to eternal sleep. */
PROCESS_THREAD(blink_process, ev, data)
{
  PROCESS_BEGIN();

  while(1) {
    static struct etimer et;
    static int onoff;

    /* before sleep, we blink a little */
    onoff = !onoff;
    if(onoff) {
      leds_on(LEDS_ALL);
    } else {
      leds_off(LEDS_ALL);
    }
    etimer_set(&et, CLOCK_SECOND / 8);
    PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));

#define TIME_BEFORE_ETERNAL_SLEEP (10) // seconds
    if(clock_seconds() >= TIME_BEFORE_ETERNAL_SLEEP) {
      /* turn off all LEDs to be as power efficient as possible */
      leds_off(LEDS_ALL);

      /* don't wake up from the watchdog or other interrupts (eg timers) */
      watchdog_stop();
      dint();

      /* enter low-power mode */
      LPM3;
      /* ... and rest in peace; only reset/POR can resurrect us now */
    }
  }
  PROCESS_END();
}

/*---------------------------------------------------------------------------*/
rpl_parent_t *
rpl_add_parent(rpl_dag_t *dag, rpl_dio_t *dio, uip_ipaddr_t *addr)
{
  rpl_parent_t *p = NULL;
  /* Is the parent known by ds6? Drop this request if not.
   * Typically, the parent is added upon receiving a DIO. */
  uip_lladdr_t *lladdr = uip_ds6_nbr_lladdr_from_ipaddr(addr);

//  PRINTF("RPL: rpl_add_parent lladdr %p\n", lladdr);
  if(lladdr != NULL) {
    /* Add parent in rpl_parents */
    p = nbr_table_add_lladdr(rpl_parents, (rimeaddr_t *)lladdr);
    p->dag = dag;
    p->rank = dio->rank;
    p->dtsn = dio->dtsn;
    p->rssi= cc2420_last_rssi-45;
    p->update_time = clock_seconds();
if(dag->rank > p->rank)
    p->flag= PRNT;
else
   p->flag=NBR;
    p->link_metric = RPL_INIT_LINK_METRIC * RPL_DAG_MC_ETX_DIVISOR;

#if RPL_DAG_MC != RPL_DAG_MC_NONE
    memcpy(&p->mc, &dio->mc, sizeof(p->mc));
#endif /* RPL_DAG_MC != RPL_DAG_MC_NONE */
  }

  return p;
}

/**
 * send the broadcast list to the neighbor
 */
void send_br_list(struct broadcast_conn *broadcastConn){
    Br_msg_list *br_msg_list;
    Br_msg_list *remove;
    if(list_length(broadcast_list)>0){
        for(br_msg_list = list_head(broadcast_list);br_msg_list!=NULL;){
            packetbuf_copyfrom(&br_msg_list->broadcast_msg,sizeof(Broadcast_msg));
            printf("[BC] @%d @%u.%u base [email protected]%u.%u\n", clock_seconds(),rimeaddr_node_addr.u8[0],rimeaddr_node_addr.u8[1],
                   br_msg_list->broadcast_msg.base_station.u8[0],br_msg_list->broadcast_msg.base_station.u8[1]);
            broadcast_send(broadcastConn);
            packetbuf_clear();
            print_br_list();
            remove = br_msg_list;
            br_msg_list = br_msg_list->next;
            if(local_node.sen_type == BASE_STATION && (remove->broadcast_msg.msg_type==SUBSCRIBE||
                                                       remove->broadcast_msg.msg_type==UNSUBSCRIBE)){
            }else if(remove!=NULL&&list_length(broadcast_list)>1){
                list_remove(broadcast_list,remove);
                memb_free(&broadcast_list_memb, remove);
                printf("[DELET-BR-MSG] msg sub_type %u msg_type %u br list length %u\n",remove->broadcast_msg.subscribe_type,
                       remove->broadcast_msg.msg_type,list_length(broadcast_list));
                remove = NULL;
                break;
            }
        }
    }

}

/*---------------------------------------------------------------------------*/
static unsigned short
generate_radio_stats(void *arg)
{
  uint16_t numprinted;
  uint16_t h,m,s;
  uint8_t p1,p2;
  unsigned long seconds=clock_seconds();
  static const char httpd_cgi_sensor10[] HTTPD_STRING_ATTR = "<em>Radio on time  :</em> %02d:%02d:%02d (%d.%02d%%)<br>";
  static const char httpd_cgi_sensor11[] HTTPD_STRING_ATTR = "<em>Packets:</em> Tx=%5d Rx=%5d  TxL=%5d RxL=%5d RSSI=%2ddBm\n";

  s=(10000UL*savedradioontime)/seconds;
  p1=s/100;
  p2=s-p1*100;
  h=savedradioontime/3600;
  s=savedradioontime-h*3600;
  m=s/60;
  s=s-m*60;

  numprinted =httpd_snprintf((char *)uip_appdata             , uip_mss()             , httpd_cgi_sensor10,\
    h,m,s,p1,p2);

#if RF230BB
  numprinted+=httpd_snprintf((char *)uip_appdata + numprinted, uip_mss() - numprinted, httpd_cgi_sensor11,\
    RF230_sendpackets,RF230_receivepackets,RF230_sendfail,RF230_receivefail,-92+rf230_last_rssi);
#else
  p1=0;
  radio_get_rssi_value(&p1);
  p1 = -91*3(p1-1);
  numprinted+=httpd_snprintf((char *)uip_appdata + numprinted, uip_mss() - numprinted, httpd_cgi_sensor11,\
    RF230_sendpackets,RF230_receivepackets,RF230_sendfail,RF230_receivefail,p1);
#endif
 
  return numprinted;
}

static void recv_uc(struct unicast_conn *c, const rimeaddr_t * from)
{
    sec_since_start = clock_seconds();
    printf("\n%d - MSG from %d.%d\n", sec_since_start, from->u8[0], from->u8[1]);
    
    msg = (struct unicast_message *)packetbuf_dataptr();  
    packetbuf_clear();  
    //printf("MSG TYPE: %d \tCMD: %s \tVALUE: %d\n", msg->type, get_cmd(msg->cmd), msg->value);
    switch (msg->cmd) {
    case CMD_FAN_ON:
	printf("PG:FAN ON\n");
	break;
    case CMD_FAN_OFF:
	printf("PG:FAN OFF\n");
	break;
    case CMD_HEATER_ON:
	printf("PG:HEAT ON\n");
	break;
    case CMD_HEATER_OFF:
	printf("PG:HEAT OFF\n");
	break;
    case CMD_LIGHT_ON:
	printf("PG:LIGHT ON\n");
	break;
    case CMD_LIGHT_OFF:
	printf("PG:LIGHT OFF\n");
	break;
    default:
	printf("\n%s\n", get_cmd(msg->cmd));
    }

}

static void discovery_ipnd_neighbour_update_ip(const cl_addr_t* const addr, struct discovery_ipnd_neighbour_list_entry* const entry)
{
	entry->addr_type |= CL_TYPE_FLAG_DGRAM_UDP;
	ip_addr_copy(entry->ip, addr->ip);
	entry->port = addr->port;
	// TODO update ip timestamp
	entry->timestamp_last_ip = clock_seconds();
}

/*---------------------------------------------------------------------------*/
static void
tcpip_handler(void)
{
  if(uip_newdata() && (uip_datalen()==48)) {
    CurrTime = uip_ntohl(((struct ntpformat *)uip_appdata)->seconds) - NTP_EPOCH;
    StartTime = clock_seconds();
  }
}