void gnrc_gomach_set_netdev_state(gnrc_netif_t *netif, netopt_state_t devstate)
{
assert(netif != NULL);
netif->dev->driver->set(netif->dev,
NETOPT_STATE,
&devstate,
sizeof(devstate));
#if (GNRC_GOMACH_ENABLE_DUTYCYLE_RECORD == 1)
if (devstate == NETOPT_STATE_IDLE) {
if (!(netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_RADIO_IS_ON)) {
netif->mac.prot.gomach.last_radio_on_time_ticks = xtimer_now_usec64();
netif->mac.prot.gomach.gomach_info |= GNRC_GOMACH_INTERNAL_INFO_RADIO_IS_ON;
}
return;
}
else if ((devstate == NETOPT_STATE_SLEEP) &&
(netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_RADIO_IS_ON)) {
netif->mac.prot.gomach.radio_off_time_ticks = xtimer_now_usec64();
netif->mac.prot.gomach.awake_duration_sum_ticks +=
(netif->mac.prot.gomach.radio_off_time_ticks -
netif->mac.prot.gomach.last_radio_on_time_ticks);
netif->mac.prot.gomach.gomach_info &= ~GNRC_GOMACH_INTERNAL_INFO_RADIO_IS_ON;
}
#endif
}
void _handle_snd_mc_ra(gnrc_netif_t *netif)
{
gnrc_netif_acquire(netif);
assert(netif != NULL);
if (!gnrc_netif_is_6ln(netif)) {
bool final_ra = (netif->ipv6.ra_sent > (UINT8_MAX - NDP_MAX_FIN_RA_NUMOF));
uint32_t next_ra_time = random_uint32_range(NDP_MIN_RA_INTERVAL_MS,
NDP_MAX_RA_INTERVAL_MS);
uint32_t next_scheduled = _evtimer_lookup(netif, GNRC_IPV6_NIB_SND_MC_RA);
/* router has router advertising interface or the RA is one of the
* (now deactivated) routers final one (and there is no next
* scheduled within the possible time for next_ra_time) */
if ((final_ra && (next_scheduled > NDP_MAX_RA_INTERVAL_MS)) ||
gnrc_netif_is_rtr_adv(netif)) {
_snd_rtr_advs(netif, NULL, final_ra);
netif->ipv6.last_ra = (xtimer_now_usec64() / US_PER_MS) & UINT32_MAX;
if ((netif->ipv6.ra_sent < NDP_MAX_INIT_RA_NUMOF) || final_ra) {
if ((netif->ipv6.ra_sent < NDP_MAX_INIT_RA_NUMOF) &&
(next_ra_time > NDP_MAX_INIT_RA_INTERVAL)) {
next_ra_time = NDP_MAX_INIT_RA_INTERVAL;
}
netif->ipv6.ra_sent++;
}
/* netif->ipv6.ra_sent overflowed => this was our last final RA */
if (netif->ipv6.ra_sent != 0) {
_evtimer_add(netif, GNRC_IPV6_NIB_SND_MC_RA, &netif->ipv6.snd_mc_ra,
next_ra_time);
}
}
}
gnrc_netif_release(netif);
}
static void _cp_packet_process_data(gnrc_netif_t *netif,
gnrc_gomach_packet_info_t *info,
gnrc_pktsnip_t *pkt)
{
if (memcmp(&netif->l2addr, &info->dst_addr.addr,
netif->l2addr_len) == 0) {
/* The data is for itself, now update the sender's queue-length indicator. */
gnrc_gomach_indicator_update(netif, pkt, info);
/* Check that whether this is a duplicate packet. */
if ((gnrc_gomach_check_duplicate(netif, info))) {
gnrc_pktbuf_release(pkt);
LOG_DEBUG("[GOMACH]: received a duplicate packet.\n");
return;
}
gnrc_gomach_dispatch_defer(netif->mac.rx.dispatch_buffer, pkt);
gnrc_mac_dispatch(&netif->mac.rx);
#if (GNRC_GOMACH_ENABLE_DUTYCYLE_RECORD == 1)
/* Output radio duty-cycle ratio */
uint64_t duty;
duty = xtimer_now_usec64();
duty = (netif->mac.prot.gomach.awake_duration_sum_ticks) * 100 /
(duty - netif->mac.prot.gomach.system_start_time_ticks);
printf("[GoMacH]: achieved radio duty-cycle: %lu %% \n", (uint32_t)duty);
#endif
}
else {
/* If the data is not for the device, release it. */
gnrc_pktbuf_release(pkt);
}
}
u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t count)
{
LWIP_ASSERT("invalid semaphor", sys_sem_valid(sem));
if (count != 0) {
uint64_t stop, start;
start = xtimer_now_usec64();
int res = sema_wait_timed((sema_t *)sem, count * US_PER_MS);
stop = xtimer_now_usec64() - start;
if (res == -ETIMEDOUT) {
return SYS_ARCH_TIMEOUT;
}
return (u32_t)(stop / US_PER_MS);
}
else {
sema_wait_timed((sema_t *)sem, 0);
return 0;
}
}
static uint32_t _get_offset(xtimer_t *timer)
{
uint64_t now_us = xtimer_now_usec64();
uint64_t target_us = _xtimer_usec_from_ticks64(
((uint64_t)timer->long_target) << 32 | timer->target);
if (target_us <= now_us) {
return 0;
}
else {
target_us -= now_us;
/* add half of 125 so integer division rounds to nearest */
return div_u64_by_125((target_us >> 3) + 62);
}
}
uint64_t gnrc_gomach_phase_now(gnrc_netif_t *netif)
{
assert(netif != NULL);
uint64_t phase_now = xtimer_now_usec64();
/* in case timer overflows */
if (phase_now < netif->mac.prot.gomach.last_wakeup_phase_us) {
uint64_t gap_to_full = GNRC_GOMACH_PHASE_MAX -
netif->mac.prot.gomach.last_wakeup_phase_us;
phase_now += gap_to_full;
}
else {
phase_now = phase_now - netif->mac.prot.gomach.last_wakeup_phase_us;
}
return phase_now;
}
int sntp_sync(sock_udp_ep_t *server, uint32_t timeout)
{
int result;
if ((result = sock_udp_create(&_sntp_sock,
NULL,
server,
0)) < 0) {
DEBUG("Error creating UDP sock\n");
return result;
}
memset(&_sntp_packet, 0, sizeof(_sntp_packet));
ntp_packet_set_vn(&_sntp_packet);
ntp_packet_set_mode(&_sntp_packet, NTP_MODE_CLIENT);
if ((result = (int)sock_udp_send(&_sntp_sock,
&_sntp_packet,
sizeof(_sntp_packet),
NULL)) < 0) {
DEBUG("Error sending message\n");
sock_udp_close(&_sntp_sock);
return result;
}
if ((result = (int)sock_udp_recv(&_sntp_sock,
&_sntp_packet,
sizeof(_sntp_packet),
timeout,
NULL)) < 0) {
DEBUG("Error receiving message\n");
sock_udp_close(&_sntp_sock);
return result;
}
sock_udp_close(&_sntp_sock);
mutex_lock(&_sntp_mutex);
_sntp_offset = (((int64_t)byteorder_ntohl(_sntp_packet.transmit.seconds)) * US_PER_SEC) +
((((int64_t)byteorder_ntohl(_sntp_packet.transmit.fraction)) * 232)
/ 1000000) - xtimer_now_usec64();
mutex_unlock(&_sntp_mutex);
return 0;
}
static int pthread_rwlock_timedlock(pthread_rwlock_t *rwlock,
bool (*is_blocked)(const pthread_rwlock_t *rwlock),
bool is_writer,
int incr_when_held,
const struct timespec *abstime)
{
uint64_t now = xtimer_now_usec64();
uint64_t then = ((uint64_t)abstime->tv_sec * US_PER_SEC) +
(abstime->tv_nsec / NS_PER_US);
if ((then - now) <= 0) {
return ETIMEDOUT;
}
else {
xtimer_t timer;
xtimer_set_wakeup64(&timer, (then - now), sched_active_pid);
int result = pthread_rwlock_lock(rwlock, is_blocked, is_writer, incr_when_held, true);
if (result != ETIMEDOUT) {
xtimer_remove(&timer);
}
return result;
}
}
va_start(argp, fmt);
verrx(eval, fmt, argp);
va_end(argp);
}
int getpid(void)
{
warnx("not implemented");
return -1;
}
#ifdef MODULE_XTIMER
int _gettimeofday(struct timeval *tp, void *restrict tzp)
{
(void) tzp;
uint64_t now = xtimer_now_usec64();
tp->tv_sec = now / US_PER_SEC;
tp->tv_usec = now - tp->tv_sec;
return 0;
}
#endif
/**
* set up native internal syscall symbols
*/
void _native_init_syscalls(void)
{
*(void **)(&real_read) = dlsym(RTLD_NEXT, "read");
*(void **)(&real_write) = dlsym(RTLD_NEXT, "write");
*(void **)(&real_malloc) = dlsym(RTLD_NEXT, "malloc");
*(void **)(&real_calloc) = dlsym(RTLD_NEXT, "calloc");
