自学教程：C++ watchdog_periodic函数代码示例

/** * @brief transmit_epidemic */static void transmit_epidemic(){    packetbuf_clear();        data_packet_t *dpkt = (data_packet_t*)packetbuf_dataptr();        if(isAnchorFlag){        dpkt->type = ANCHOR_PKT;    }else{        dpkt->type = PROBE_PKT;    }    //add sender offset.    dpkt->offset   = probe_offset;    dpkt->period   = get_node_period();    dpkt->src_id   = rimeaddr_node_addr.u8[0];        uint8_t pldSize = 0;    if(radio_read_flag == 0){        if(list_access_flag == 0){            list_access_flag = 1;            pldSize = neighs_add2payload(&dpkt->data[0], isAnchorFlag, probe_offset);            list_access_flag = 0;        }        //if(pldSize){            rtimer_clock_t t0;            uint8_t i = 0, pkt_seen = 0, ccaCounter= 0;            //ccaCounter= randomint_between(CCA_COUNT_MAX, CCA_COUNT_MAX_TX);	    ccaCounter = /*CCA_COUNT_MAX +*/ random_int(CCA_COUNT_MAX_TX);	    //watchdog	    watchdog_periodic();	                 for( i = 0; i < ccaCounter && beacon_2_flag; i++){		//watchdog		watchdog_periodic();					                t0 = RTIMER_NOW();                while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_CHECK_TIME)){                    //do nothing.. KUNANGA                }                if(NETSTACK_RADIO.channel_clear() == 0){                    pkt_seen = 1;                    break; // maybe return here .. collision is expected                }            }            if((pkt_seen == 0) && (radio_read_flag == 0)){                NETSTACK_RADIO.send((void*)packetbuf_dataptr(),DATAPKT_HDR_LEN + pldSize);            }        //} //end of pldSize    }}

/*---------------------------------------------------------------------------*/voiduart1_writeb(unsigned char c){  watchdog_periodic();#if TX_WITH_INTERRUPT  /* Put the outgoing byte on the transmission buffer. If the buffer     is full, we just keep on trying to put the byte into the buffer     until it is possible to put it there. */  while(ringbuf_put(&txbuf, c) == 0);  /* If there is no transmission going, we need to start it by putting     the first byte into the UART. */  if(transmitting == 0) {    transmitting = 1;    UCA0TXBUF = ringbuf_get(&txbuf);  }#else /* TX_WITH_INTERRUPT */ /* Loop until the transmission buffer is available. */  while(!(IFG2 & UCA0TXIFG));    // Wait for TX buffer ready to receive new byte        UCA0TXBUF = c; //c;            // Output character#endif /* TX_WITH_INTERRUPT */}

voidAppColdStart(void){  /* default startup */  init_hardware();  process_init();  procinit_init();  init_net();  jts_init();  /* application startup */  autostart_start(autostart_processes);  /* enable watchdog on JN5148, there is none on JN5139 */#ifdef __BA2__  watchdog_start();#endif  /* default main loop */  while(1)  {    process_run();    etimer_request_poll();#ifdef __BA2__    watchdog_periodic();#endif  }}

/** * /brief This function is called by the 6lowpan code to send out a * packet. * /param dest the link layer destination address of the packet */static voidsend_packet(struct net_buf *buf, linkaddr_t *dest, bool last_fragment, void *ptr){  /* Set the link layer destination address for the packet as a   * packetbuf attribute. The MAC layer can access the destination   * address with the function packetbuf_addr(PACKETBUF_ADDR_RECEIVER).   */  packetbuf_set_addr(buf, PACKETBUF_ADDR_RECEIVER, dest);#if NETSTACK_CONF_BRIDGE_MODE  /* This needs to be explicitly set here for bridge mode to work */  packetbuf_set_addr(buf, PACKETBUF_ADDR_SENDER,(void*)&uip_lladdr);#endif  /* Force acknowledge from sender (test hardware autoacks) */#if SICSLOWPAN_CONF_ACK_ALL  packetbuf_set_attr(buf, PACKETBUF_ATTR_RELIABLE, 1);#endif  /* Provide a callback function to receive the result of     a packet transmission. */  NETSTACK_LLSEC.send(buf, &packet_sent, last_fragment, ptr);  /* If we are sending multiple packets in a row, we need to let the     watchdog know that we are still alive. */  watchdog_periodic();}

/*---------------------------------------------------------------------------*/static cfs_offset_tfile_end(coffee_page_t start){    struct file_header hdr;    unsigned char buf[COFFEE_PAGE_SIZE];    coffee_page_t page;    int i;    read_header(&hdr, start);    /*     * Move from the end of the range towards the beginning and look for     * a byte that has been modified.     *     * An important implication of this is that if the last written bytes     * are zeroes, then these are skipped from the calculation.     */    for(page = hdr.max_pages - 1; page >= 0; page--) {        watchdog_periodic();        COFFEE_READ(buf, sizeof(buf), (start + page) * COFFEE_PAGE_SIZE);        for(i = COFFEE_PAGE_SIZE - 1; i >= 0; i--) {            if(buf[i] != 0) {                if(page == 0 && i < sizeof(hdr)) {                    return 0;                }                return 1 + i + (page * COFFEE_PAGE_SIZE) - sizeof(hdr);            }        }    }    /* All bytes are writable. */    return 0;}

/*---------------------------------Main Routine----------------------------*/intmain(void){  /* GCC depends on register r1 set to 0 (?) */  asm volatile ("clr r1");    /* Initialize in a subroutine to maximize stack space */  initialize();#if DEBUG{struct process *p; for(p = PROCESS_LIST();p != NULL; p = ((struct process *)p->next)) {  PRINTA("Process=%p Thread=%p  Name=/"%s/" /n",p,p->thread,PROCESS_NAME_STRING(p)); }}#endif  while(1) {    process_run();    watchdog_periodic();  }  return 0;}

/*---------------------------------------------------------------------------*/static interase(unsigned long from, unsigned long to){  enum status_code ret;  unsigned long addr;  if (!opened) {    return -1;  }  from = (from / SECTOR_SIZE) * SECTOR_SIZE;  to   = (to   / SECTOR_SIZE) * SECTOR_SIZE;  for(addr = from; addr < to; addr += SECTOR_SIZE) {    TRACE("addr: %ld", addr);    if ((ret = nvm_erase_row(addr)) != STATUS_OK) {      WARN("nvm_erase_row error: %d", ret);      return -1;    }    watchdog_periodic();  }  while (!nvm_is_ready());  return 1;}

/*---------------------------------------------------------------------------*/static int32_tfind_file(const char *name){  struct file_header hdr;  int32_t page;  page = dir_cache_find(name);  if(page >= 0) {    return page;  }    page = 0;  do {    READ_HEADER(&hdr, page);    if(COFFEE_PAGE_ACTIVE(hdr)) {      if(strcmp(name, hdr.name) == 0) {	dir_cache_add(name[0], page);	return page;      }      page += hdr.max_pages;    } else if(COFFEE_PAGE_ISOLATED(hdr)) {      ++page;    } else if(COFFEE_PAGE_OBSOLETE(hdr)) {      page += hdr.max_pages;    } else {      /* It follows from the properties of the page allocation algorithm 	 that if a free page is encountered, then the rest of the sector	 is also free. */      page = (page + COFFEE_PAGES_PER_SECTOR) & ~(COFFEE_PAGES_PER_SECTOR - 1);    }    watchdog_periodic();  } while(page < COFFEE_PAGE_COUNT);    return -1;}

/*---------------------------------------------------------------------------*/voiduart1_writeb(unsigned char c){  watchdog_periodic();#if TX_WITH_INTERRUPT  /* Put the outgoing byte on the transmission buffer. If the buffer     is full, we just keep on trying to put the byte into the buffer     until it is possible to put it there. */  while(ringbuf_put(&txbuf, c) == 0);  /* If there is no transmission going, we need to start it by putting     the first byte into the UART. */  if(transmitting == 0) {    transmitting = 1;    /* Loop until the transmission buffer is available. */    /*while((IFG2 & UTXIFG1) == 0);*/    TXBUF1 = ringbuf_get(&txbuf);  }#else /* TX_WITH_INTERRUPT */  /* Loop until the transmission buffer is available. */  while((IFG2 & UTXIFG1) == 0);  /* Transmit the data. */  TXBUF1 = c;#endif /* TX_WITH_INTERRUPT */}

voidJump_To_Bootloader(void){  /* Disable all interrupts */  cli();#ifdef UDCON  /* If USB is used, detach from the bus */  Usb_detach();  uint8_t i;  /* Wait two seconds for the USB detachment to register on the host */  for(i = 0; i < 200; i++) {    _delay_ms(10);    watchdog_periodic();  }#endif  /* Set the bootloader key to the magic value and force a reset */  Boot_Key = MAGIC_BOOT_KEY;  eeprom_write_byte(EEPROM_MAGIC_BYTE_ADDR, 0xFF);  /* Enable interrupts */  sei();  watchdog_reboot();}

/*---------------------------------------------------------------------------*/voiduart1_writeb(unsigned char c){  watchdog_periodic();#if TX_WITH_INTERRUPT  /*   * Put the outgoing byte on the transmission buffer. If the buffer   * is full, we just keep on trying to put the byte into the buffer   * until it is possible to put it there.   */  while(ringbuf_put(&txbuf, c) == 0);  /*   * If there is no transmission going, we need to start it by putting   * the first byte into the UART.   */  if(transmitting == 0) {    transmitting = 1;    SC1_DATA = ringbuf_get(&txbuf);    INT_SC1FLAG = INT_SCTXFREE;    INT_SC1CFG |= INT_SCTXFREE;  }#else /* TX_WITH_INTERRUPT */  /* Loop until the transmission buffer is available. */  while((INT_SC1FLAG & INT_SCTXFREE) == 0);  /* Transmit the data. */  SC1_DATA = c;  INT_SC1FLAG = INT_SCTXFREE;#endif /* TX_WITH_INTERRUPT */}

/*---------------------------------------------------------------------------*/voidsci3_writeb(unsigned char c){  watchdog_periodic();#if 1  /* Put the outgoing byte on the transmission buffer. If the buffer     is full, we just keep on trying to put the byte into the buffer     until it is possible to put it there. */  while(ringbuf_put(&txbuf, c) == 0);  /* If there is no transmission going, we need to start it by putting     the first byte into the UART. */  if(transmitting == 0) {    transmitting = 1;    /* Loop until the transmission buffer is available. */    /*while((IFG2 & UTXIFG1) == 0);*/    //TXBUF1 = ringbuf_get(&txbuf);    SCI3.SCR3.BYTE |= 0x04; /*  */    SCI3.SSR.BYTE &= ~0x04; /* reset TxEI request */  }#else /* TX_WITH_INTERRUPT */  /* Loop until the transmission buffer is available. */  while (!(SCI3.SSR.BIT.TDRE));  /* Transmit the data. */  SCI3.TDR = c;  SCI3.SSR.BIT.TDRE = 0;#endif /* TX_WITH_INTERRUPT */}

/*---------------------------------------------------------------------------*/static voidsend_broadcast(mac_callback_t sent, void *ptr){    struct queuebuf *qb;    qb = queuebuf_new_from_packetbuf();    if(!qb || (NETSTACK_FRAMER.create() < 0)) {        PRINTF("coresec-strategy: Did not send broadcast/n");        if(qb) {            queuebuf_free(qb);        }        sent(ptr, MAC_TX_ERR, 0);        return;    }    prepare_announce();    adaptivesec_send_command_frame();    watchdog_periodic();    queuebuf_to_packetbuf(qb);    queuebuf_free(qb);#if WITH_BROADCAST_ENCRYPTION    {        uint8_t ignore[ADAPTIVESEC_BROADCAST_MIC_LEN];        if(packetbuf_attr(PACKETBUF_ATTR_SECURITY_LEVEL) & (1 << 2)) {            adaptivesec_aead(adaptivesec_group_key, 1, ignore, 1);        }    }#endif /* WITH_BROADCAST_ENCRYPTION */    NETSTACK_MAC.send(sent, ptr);}

uint16_t aes_encrypt(uint8_t * output, const uint8_t * data, uint16_t size) {	static uint16_t i;	static uint8_t *current_iv;	watchdog_periodic();	current_iv = output+(size+AES_BLOCK_SIZE-(size-1)%AES_BLOCK_SIZE-1);#if AES_ALWAYS_SET_KEY	ENCCS = AES_DEFAULT_MODE | AES_CMD_LOAD_KEY | AES_START;	AES_DOWNLOAD(current_key, AES_KEY_SIZE);	AES_WAIT();#endif#if AES_USE_MAC	// load MAC with IV 0	ENCCS = AES_CBCMAC_MODE | AES_CMD_LOAD_IV | AES_START;	AES_DOWNLOAD(zero, AES_BLOCK_SIZE);	AES_WAIT();	// load data	ENCCS = AES_CBCMAC_MODE | AES_CMD_LOAD_IV;	for( i = 0 ; i < size-AES_BLOCK_SIZE ; i += AES_BLOCK_SIZE ) {		ENCCS |= AES_START;		AES_DOWNLOAD(data+i,AES_BLOCK_SIZE);		AES_WAIT();	}	ENCCS = AES_CBC_MODE | AES_CMD_LOAD_IV | AES_START;	AES_DOWNLOAD(data+i,size-i);	AES_DOWNLOAD(zero,AES_BLOCK_SIZE-(size-i));	AES_WAIT();	AES_UPLOAD(current_iv+AES_BLOCK_SIZE,AES_BLOCK_SIZE);#endif	// first byte of IV stores how many bytes is necessary to complete the last block	current_iv[0] = (current_iv-output)-size;	for( i = 1 ; i < AES_BLOCK_SIZE ; ++i ) current_iv[i] = random_rand();	ENCCS = AES_DEFAULT_MODE | AES_CMD_LOAD_IV | AES_START;	AES_DOWNLOAD(current_iv, AES_BLOCK_SIZE);	AES_WAIT();	// load data	ENCCS = AES_DEFAULT_MODE | AES_CMD_ENCRYPT;	for( i = 0 ; i < size-AES_BLOCK_SIZE ; i += AES_BLOCK_SIZE ) {		ENCCS |= AES_START;		AES_DOWNLOAD(data+i,AES_BLOCK_SIZE);		AES_WAIT();		AES_UPLOAD(output+i,AES_BLOCK_SIZE);	}	// last block	ENCCS |= AES_START;	AES_DOWNLOAD(data+i,size-i);	AES_DOWNLOAD(zero,AES_BLOCK_SIZE-(size-i));	AES_WAIT();	AES_UPLOAD(output+i,AES_BLOCK_SIZE);	size += current_iv[0] + AES_BLOCK_SIZE;#if AES_USE_MAC	size += AES_BLOCK_SIZE;#endif	return size;}

uint16_t aes_decrypt(uint8_t * output, const uint8_t * data, uint16_t size) {	static uint16_t i;	static uint8_t *current_iv;	watchdog_periodic();#if AES_ALWAYS_SET_KEY	ENCCS = AES_DEFAULT_MODE | AES_CMD_LOAD_KEY | AES_START;	AES_DOWNLOAD(current_key, AES_KEY_SIZE);	AES_WAIT();#endif#if AES_USE_MAC	size -= 2*AES_BLOCK_SIZE;#else	size -= AES_BLOCK_SIZE;#endif	current_iv = data+size;	ENCCS = AES_DEFAULT_MODE | AES_CMD_LOAD_IV | AES_START;	AES_DOWNLOAD(current_iv, AES_BLOCK_SIZE);	AES_WAIT();	ENCCS = AES_DEFAULT_MODE | AES_CMD_DECRYPT;	for( i = 0 ; i < size-AES_BLOCK_SIZE ; i += AES_BLOCK_SIZE ) {		ENCCS |= AES_START;		AES_DOWNLOAD(data+i,AES_BLOCK_SIZE);		AES_WAIT();		AES_UPLOAD(output+i,AES_BLOCK_SIZE);	}	// last block	ENCCS |= AES_START;	AES_DOWNLOAD(data+i,AES_BLOCK_SIZE);	AES_WAIT();	AES_UPLOAD(output+i,size-i);#if AES_USE_MAC	// load MAC with IV 0	ENCCS = AES_CBCMAC_MODE | AES_CMD_LOAD_IV | AES_START;	AES_DOWNLOAD(zero, AES_BLOCK_SIZE);	AES_WAIT();	// load data	ENCCS = AES_CBCMAC_MODE | AES_CMD_LOAD_IV;	for( i = 0 ; i < size-AES_BLOCK_SIZE ; i += AES_BLOCK_SIZE ) {		ENCCS |= AES_START;		AES_DOWNLOAD(output+i,AES_BLOCK_SIZE);		AES_WAIT();	}	ENCCS = AES_CBC_MODE | AES_CMD_LOAD_IV | AES_START;	AES_DOWNLOAD(output+i,size-i);	AES_DOWNLOAD(zero,AES_BLOCK_SIZE-(size-i));	AES_WAIT();	for( i = 0 ; i < AES_BLOCK_SIZE ; ++i ) {		uint8_t tmp = ENCDO;		if( (current_iv+AES_BLOCK_SIZE)[i] != tmp ) return -1; // 0xffff	}#endif	return size;}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(myTimer_process, ev, data){  static rtimer_clock_t t0;  PROCESS_BEGIN();  printf("I start the timer (1 s.)/n");  while(1) {    watchdog_periodic();    t0 = RTIMER_NOW();    while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + RTIMER_SECOND));    watchdog_periodic();    timeout_handler();  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/voidcfs_coffee_arch_erase(uint16_t sector){  watchdog_periodic();  INTERRUPTS_DISABLE();  rom_util_page_erase(COFFEE_START + sector * COFFEE_SECTOR_SIZE,                      COFFEE_SECTOR_SIZE);  INTERRUPTS_ENABLE();}

/*---------------------------------------------------------------------------*/voidcfs_coffee_arch_write(const void *buf, unsigned int size, cfs_offset_t offset){  const uint32_t *src = buf;  uint32_t flash_addr = COFFEE_START + offset;  unsigned int align;  uint32_t word, len;  uint32_t page_buf[COFFEE_PAGE_SIZE / FLASH_WORD_SIZE];  unsigned int i;  if(size && (align = flash_addr & (FLASH_WORD_SIZE - 1))) {    len = MIN(FLASH_WORD_SIZE - align, size);    word = ~((*src & ((1 << (len << 3)) - 1)) << (align << 3));    watchdog_periodic();    INTERRUPTS_DISABLE();    rom_util_program_flash(&word, flash_addr & ~(FLASH_WORD_SIZE - 1),                           FLASH_WORD_SIZE);    INTERRUPTS_ENABLE();    *(const uint8_t **)&src += len;    size -= len;    flash_addr += len;  }  while(size >= FLASH_WORD_SIZE) {    len = MIN(size & ~(FLASH_WORD_SIZE - 1), COFFEE_PAGE_SIZE);    for(i = 0; i < len / FLASH_WORD_SIZE; i++) {      page_buf[i] = ~*src++;    }    watchdog_periodic();    INTERRUPTS_DISABLE();    rom_util_program_flash(page_buf, flash_addr, len);    INTERRUPTS_ENABLE();    size -= len;    flash_addr += len;  }  if(size) {    word = ~(*src & ((1 << (size << 3)) - 1));    watchdog_periodic();    INTERRUPTS_DISABLE();    rom_util_program_flash(&word, flash_addr, FLASH_WORD_SIZE);    INTERRUPTS_ENABLE();  }}

/*---------------------------------------------------------------------------*/voiduart1_writeb(unsigned char c){  watchdog_periodic();  /* Loop until the transmission buffer is available. */  while((UCA1STAT & UCBUSY));  /* Transmit the data. */  UCA1TXBUF = c;}

/* * Wait for a write/erase operation to finish. */static unsignedwait_ready(void){  unsigned u;  do {    u = read_status_register();    watchdog_periodic();  } while(u & 0x01);		/* WIP=1, write in progress */  return u;}

/*---------------------------------------------------------------------------*/voidcfs_coffee_arch_read(void *buf, unsigned int size, cfs_offset_t offset){  const uint8_t *src;  uint8_t *dst;  watchdog_periodic();  for(src = (const void *)(COFFEE_START + offset), dst = buf; size; size--) {    *dst++ = ~*src++;  }}

/*---------------------------------------------------------------------------*/intcfs_read(int fd, void *buf, unsigned size){    struct file_header hdr;    struct file_desc *fdp;    struct file *file;    unsigned bytes_left;    int r;#if COFFEE_MICRO_LOGS    struct log_param lp;#endif    if(!(FD_VALID(fd) && FD_READABLE(fd))) {        return -1;    }    fdp = &coffee_fd_set[fd];    file = fdp->file;    if(fdp->offset + size > file->end) {        size = file->end - fdp->offset;    }    bytes_left = size;    if(FILE_MODIFIED(file)) {        read_header(&hdr, file->page);    }    /*     * Fill the buffer by copying from the log in first hand, or the     * ordinary file if the page has no log record.     */    while(bytes_left) {        watchdog_periodic();        r = -1;#if COFFEE_MICRO_LOGS        if(FILE_MODIFIED(file)) {            lp.offset = fdp->offset;            lp.buf = buf;            lp.size = bytes_left;            r = read_log_page(&hdr, file->record_count, &lp);        }#endif /* COFFEE_MICRO_LOGS */        /* Read from the original file if we cannot find the data in the log. */        if(r < 0) {            r = bytes_left;            COFFEE_READ(buf, r, absolute_offset(file->page, fdp->offset));        }        bytes_left -= r;        fdp->offset += r;        buf += r;    }    return size;}

/* * Probe I2C bus for PMS5003 device  */uint8_tpms5003_i2c_probe(void) {  watchdog_periodic();  if(!i2c_start(I2C_PMS5003_ADDR)) {    i2c_stop();    i2c_probed |= I2C_PMS5003;    return 1;  }  i2c_probed &= ~I2C_PMS5003;  return 0;}

/*---------------------------------------------------------------------------*/static int32_tfind_offset_in_file(int first_page){  struct file_header hdr;  unsigned char buf[COFFEE_PAGE_SIZE];  int page;  int i;  int search_limit;  uint32_t range_start, range_end, part_size;  READ_HEADER(&hdr, first_page);  for(search_limit = i = 0; i < sizeof(hdr.eof_hint) * CHAR_BIT; i++) {    if(hdr.eof_hint >> i) {      search_limit = i + 1;    }  }  part_size = hdr.max_pages / sizeof(hdr.eof_hint) / CHAR_BIT;  if(part_size == 0) {    part_size = 1;  }  range_start = part_size * search_limit;  range_end = range_start + part_size;  if(range_end > hdr.max_pages) {    range_end = hdr.max_pages;  }  /*   * Move from the end of the range towards the beginning and look for   * a byte that has been modified.   *   * An important implication of this is that if the last written bytes   * are zeroes, then these are skipped from the calculation.   */    for(page = first_page + range_end; page >= first_page + range_start; page--) {    watchdog_periodic();    COFFEE_READ(buf, sizeof(buf), page * COFFEE_PAGE_SIZE);    for(i = COFFEE_PAGE_SIZE - 1; i >= 0; i--) {      if(buf[i] != 0) {	if(page == first_page) {	  return i < sizeof(hdr) ? 0 : 1 + i - sizeof(hdr);	} else {	  return 1 + i + (page - first_page) * COFFEE_PAGE_SIZE - sizeof(hdr);	}      }    }  }    /* All bytes are writable. */  return 0;}

uint16_ti2c_probe(void){  int p = 0;  const char *del = ",";  uint16_t probed = 0;  watchdog_periodic();  if(!i2c_start(I2C_AT24MAC_ADDR)) {    i2c_stop();    probed |= I2C_AT24MAC;    print_delim(p++, "AT24MAC", del);  }  watchdog_periodic();  if(!i2c_start(I2C_SHT2X_ADDR)) {    i2c_stop();    probed |= I2C_SHT2X;    print_delim(p++, "SHT2X", del);  }  watchdog_periodic();  if(!i2c_start(I2C_CO2SA_ADDR)) {    i2c_stop();    probed |= I2C_CO2SA;    print_delim(p++, "CO2SA", del);  }  watchdog_periodic();  if(!i2c_start(I2C_BME280_ADDR)) {    i2c_stop();    probed |= I2C_BME280;    print_delim(p++, "BME280", del);  }  watchdog_periodic();  if(!i2c_start(I2C_PMS5003_ADDR)) {    i2c_stop();    probed |= I2C_PMS5003;    print_delim(p++, "PMS5003", del);  }  return probed;}

/* * Notify all modules that we're back on and rely on them to restore clocks * and power domains as required. */static voidwake_up(void){  lpm_registered_module_t *module;  /* Remember IRQ energest for next pass */  ENERGEST_IRQ_SAVE(irq_energest);  ENERGEST_ON(ENERGEST_TYPE_CPU);  ENERGEST_OFF(ENERGEST_TYPE_LPM);  /* Sync so that we get the latest values before adjusting recharge settings */  ti_lib_sys_ctrl_aon_sync();  /* Adjust recharge settings */  ti_lib_sys_ctrl_adjust_recharge_after_power_down();  /*   * Release the request to the uLDO   * This is likely not required, since the switch to GLDO/DCDC is automatic   * when coming back from deep sleep   */  ti_lib_prcm_mcu_uldo_configure(false);  /* Turn on cache again */  ti_lib_vims_mode_set(VIMS_BASE, VIMS_MODE_ENABLED);  ti_lib_prcm_cache_retention_enable();  ti_lib_aon_ioc_freeze_disable();  ti_lib_sys_ctrl_aon_sync();  /* Check operating conditions, optimally choose DCDC versus GLDO */  ti_lib_sys_ctrl_dcdc_voltage_conditional_control();  /*   * We may or may not have been woken up by an AON RTC tick. If not, we need   * to adjust our software tick counter   */  clock_update();  watchdog_periodic();  /* Notify all registered modules that we've just woken up */  for(module = list_head(modules_list); module != NULL;      module = module->next) {    if(module->wakeup) {      module->wakeup();    }  }}

also into the IRQ///void eeprom_write(eeprom_addr_t addr, unsigned char *buf, int size){struct timer tmr;timer_set(&tmr,1000); // deve essere almeno 1000 mswhile (1) {	watchdog_periodic();	if (timer_expired(&tmr)) {		printf("eeprom_read error/r/n");		printf("nvm_state_str.nvm_sts:%d/r/n",nvm_state_str.nvm_sts);		printf("nvm_state_str.nvm_cmd:%d/r/n",nvm_state_str.nvm_cmd);		return;		}	if (nvm_state_str.nvm_sts == nvms_WRITEDONE) {		nvm_state_str.nvm_cmd = nvmc_NONE; 		nvm_state_str.nvm_sts = nvms_NONE; 		return;		}	if (IS_BUSY || (nvm_state_str.nvm_sts != nvms_NONE)) continue;	nvm_state_str.pAddress = buf;	nvm_state_str.count = size;	nvm_state_str.Address.us = addr;	switch(nvm_state_str.Address.uc[0]) {		case 0: nvm_state_str.DevSel_W = WRITE_PAGE_0; break;		case 1: nvm_state_str.DevSel_W = WRITE_PAGE_1; break;		case 2: nvm_state_str.DevSel_W = WRITE_PAGE_2; break;		case 3: nvm_state_str.DevSel_W = WRITE_PAGE_3; break;		case 4: nvm_state_str.DevSel_W = WRITE_PAGE_4; break;		case 5: nvm_state_str.DevSel_W = WRITE_PAGE_5; break;		case 6: nvm_state_str.DevSel_W = WRITE_PAGE_6; break;		case 7: nvm_state_str.DevSel_W = WRITE_PAGE_7; break;		default: nvm_state_str.DevSel_W = WRITE_PAGE_0; break;		}	// set Master transfer mode	IIC2.ICCR1.BIT.MST = 1;	IIC2.ICCR1.BIT.TRS = 1;	//	_START_();	//	IIC2.ICSR.BIT.TEND = 0;	IIC2.ICIER.BIT.TEIE = 1;	nvm_state_str.iicStatus = iics_DEVSEL_W;	nvm_state_str.nvm_cmd = nvmc_WRITE_ARRAY;	nvm_state_str.nvm_sts = nvms_WRITEINPROGRESS;	IIC2.ICDRT = nvm_state_str.DevSel_W;	}}

static size_t memwrite_flash(void *dest, void *src, size_t len) {#if USE_BLOCKWRITING	return rom_pwrite(src, len, (off_t)(uintptr_t)dest);	// The compiler will remove everything from this point on.	// -> No #elsif needed#endif /* USE_BLOCKWRITING */	size_t written = 0;	unsigned short *lcldest = dest;	char *lclsrc = src;	unsigned short ow;	char *owptr = (char*) (&ow);#if DEBUG	if ((uintptr_t) dest & 1) {		puts("Alignment FAIL");	}#endif	//DPRINTF("Flash: %x/n", ow);	//watchdog_periodic();#if 1 != FBENCHMARK	flash_setup();#endif	while ((len & ~0x1) > written) {		owptr[0] = *lclsrc++;		owptr[1] = *lclsrc++;#if 1 !=FBENCHMARK		flash_write(lcldest, ow);#if DEBUG		printf("WRT: %p, %d, %d/n", lcldest, ow, *lcldest);		watchdog_periodic();		if (ow != *lcldest) {			printf("PANIC!");			while (1)				;		}#endif		lcldest++;#endif		written += 2;	}#if 1 != FBENCHMARK	flash_done();	IFG1 |= UTXIFG0;#endif	return written;}