// TODO support 64 bits values
void timer_msleep(int milliseconds) {
// Implements busy waiting
int startTime = timer_get_timestamp();
int elapseTime = timer_get_timestamp() - startTime;
while (milliseconds > elapseTime) {
elapseTime = timer_get_timestamp() - startTime;
}
}
void my_timer_msleep(int milliseconds) {
// Implements busy waiting
int startTime = timer_get_timestamp();
int elapseTime = timer_get_timestamp() - startTime;
while (milliseconds > elapseTime) {
if (thread_current()->status == THREAD_RUNNING)
sema_down(&sleep_sema);
elapseTime = timer_get_timestamp() - startTime;
}
}
void transport_control_step(void)
{
uint64_t next_time;
uint64_t time_now = timer_get_timestamp() + global_time;
trickle_time_update(time_now);
uint32_t error_code = mesh_srv_get_next_processing_time(&next_time);
if (error_code != NRF_SUCCESS)
{
return;
}
if (next_time < time_now)
{
async_event_t async_evt;
async_evt.callback.generic = trickle_step_callback;
async_evt.type = EVENT_TYPE_GENERIC;
event_handler_push(&async_evt);
}
else
{
if (next_time < global_time + timeslot_get_end_time())
{
timer_abort(step_timer_index);
step_timer_index = timer_order_cb(next_time - global_time, trickle_step_callback);
}
}
}
int logfile_del(char *filename)
{
logfile_t *log;
int i;
log = NULL;
for (i = 0; i < nlogfiles; i++) {
log = &logfiles[i];
if (!strcmp(log->filename, filename)) break;
log = NULL;
}
if (log == NULL) return(-1);
if (log->fp) {
flushlog(log, timer_get_timestamp());
fclose(log->fp);
}
if (log->last_msg) free(log->last_msg);
if (log->filename) free(log->filename);
if (nlogfiles == 1) {
free(logfiles);
logfiles = NULL;
} else {
memmove(logfiles + i, logfiles + i + 1, (nlogfiles - i - 1) * sizeof(logfile_t));
logfiles = realloc(logfiles, (nlogfiles - 1) * sizeof(logfile_t));
}
nlogfiles--;
return(0);
}
/* radio callback, executed in STACK_LOW */
static void tx_cb(uint8_t* data)
{
rbc_mesh_event_t tx_event;
mesh_adv_data_t* p_adv_data = mesh_packet_adv_data_get((mesh_packet_t*) data);
bool doing_tx_event = false;
if (p_adv_data != NULL &&
vh_tx_event_flag_get(p_adv_data->handle, &doing_tx_event) == NRF_SUCCESS
&& doing_tx_event
)
{
tx_event.event_type = RBC_MESH_EVENT_TYPE_TX;
tx_event.value_handle = p_adv_data->handle;
tx_event.data = p_adv_data->data;
tx_event.data_len = p_adv_data->adv_data_length - MESH_PACKET_ADV_OVERHEAD;
tx_event.version_delta = 0;
APP_ERROR_CHECK(rbc_mesh_event_push(&tx_event));
#if RBC_MESH_SERIAL
mesh_aci_rbc_event_handler(&tx_event);
#endif
}
mesh_packet_ref_count_dec((mesh_packet_t*) data); /* radio ref removed (pushed in tc_tx) */
vh_order_update(timer_get_timestamp()); /* tell the vh, so that it can push more updates */
}
/* Flush the logfiles to disk
*/
void flushlogs()
{
char *ts;
int i;
ts = timer_get_timestamp();
for (i = 0; i < nlogfiles; i++) {
flushlog(&logfiles[i], ts);
}
}
uint32_t timeslot_get_remaining_time(void)
{
if (!g_is_in_timeslot)
{
return 0;
}
uint32_t timestamp = timer_get_timestamp();
if (timestamp > g_timeslot_length - TIMESLOT_END_SAFETY_MARGIN_US)
{
return 0;
}
else
{
return (g_timeslot_length - TIMESLOT_END_SAFETY_MARGIN_US - timestamp);
}
}
/* radio callback, executed in STACK_LOW */
static void rx_cb(uint8_t* data, bool success, uint32_t crc)
{
if (success)
{
async_event_t evt;
evt.type = EVENT_TYPE_PACKET;
evt.callback.packet.payload = data;
evt.callback.packet.crc = crc;
evt.callback.packet.timestamp = timer_get_timestamp();
mesh_packet_ref_count_inc((mesh_packet_t*) data); /* event handler has a ref */
if (event_handler_push(&evt) != NRF_SUCCESS)
{
g_state.queue_saturation = true;
mesh_packet_ref_count_dec((mesh_packet_t*) data); /* event handler lost its ref */
}
}
/* no longer needed in this context */
mesh_packet_ref_count_dec((mesh_packet_t*) data);
}
/**
* @brief Handle trickle timing events
*/
static void trickle_step_callback(void)
{
TICK_PIN(6);
/* check if timeslot is about to end */
if (timeslot_get_remaining_time() < RADIO_SAFETY_TIMING_US)
return;
uint64_t time_now = global_time + timer_get_timestamp();
trickle_time_update(time_now);
packet_t packet;
bool has_anything_to_send = false;
mesh_srv_packet_assemble(&packet, PACKET_DATA_MAX_LEN * PACKET_MAX_CHAIN_LEN,
&has_anything_to_send);
if (has_anything_to_send)
{
TICK_PIN(PIN_MESH_TX);
radio_disable();
uint8_t packet_and_addr_type = PACKET_TYPE_ADV_NONCONN |
((packet.sender.addr_type == BLE_GAP_ADDR_TYPE_PUBLIC)?
0 :
PACKET_ADDR_TYPE_MASK);
uint8_t* temp_data_ptr = &packet.data[0];
uint8_t* tx_data_ptr = &tx_data[0];
tx_data_ptr[PACKET_TYPE_POS] = packet_and_addr_type;
/* Code structured for packet chaining, although this is yet
to be implemented. */
do
{
uint8_t min_len = ((packet.length > PACKET_DATA_MAX_LEN)?
PACKET_DATA_MAX_LEN :
packet.length);
tx_data_ptr[PACKET_PADDING_POS] = 0;
tx_data_ptr[PACKET_LENGTH_POS] = (min_len + PACKET_ADDR_LEN);
tx_data_ptr[PACKET_TYPE_POS] = packet_and_addr_type;
memcpy(&tx_data_ptr[PACKET_ADDR_POS], packet.sender.addr, PACKET_ADDR_LEN);
memcpy(&tx_data_ptr[PACKET_DATA_POS], &temp_data_ptr[0], min_len);
radio_event_t tx_event;
tx_event.access_address = 0;
rbc_mesh_channel_get(&tx_event.channel);
tx_event.event_type = RADIO_EVENT_TYPE_TX;
tx_event.packet_ptr = &tx_data_ptr[0];
tx_event.start_time = 0;
tx_event.callback.tx = NULL;
radio_order(&tx_event);
TICK_PIN(0);
} while (0);
order_search(); /* search for the rest of the timeslot */
}
/* order next processing */
uint64_t next_time;
uint64_t end_time = timeslot_get_end_time();
uint32_t error_code = mesh_srv_get_next_processing_time(&next_time);
if (error_code == NRF_SUCCESS && next_time < global_time + end_time)
{
timer_abort(step_timer_index);
step_timer_index = timer_order_cb(next_time - global_time, trickle_step_callback);
}
}
static int on_putlog(int flags, const char *chan, const char *text, int len)
{
char *ts;
int i;
ts = timer_get_timestamp();
for (i = nlogfiles - 1; i >= 0; i--) {
logfile_t *log = &logfiles[i];
/* If this log is disabled, skip it */
if (log->state != LOG_STATE_ENABLED)
continue;
/* If this log doesn't match, skip it. */
if (!(log->mask & flags)) {
continue;
}
if (chan[0] != '*' && log->chname[0] != '*' && irccmp(chan, log->chname)) continue;
/* If it's a repeat message, don't write it again. */
if (log->last_msg && !strcasecmp(text, log->last_msg)) {
log->repeats++;
continue;
}
/* If there was a repeated message, write the count. */
if (log->repeats) {
fprintf(log->fp, "%s", ts);
fprintf(log->fp, _("Last message repeated %d time(s).\n"), log->repeats);
log->repeats = 0;
}
/* Save this msg to check for repeats next time. */
str_redup(&log->last_msg, text);
if (log->fp == NULL) {
if (log->fname == NULL) {
char buf[1024];
time_t now;
now = time(NULL);
strftime(buf, sizeof(buf), log->filename, localtime(&now));
log->fname = strdup(buf);
}
log->fp = fopen(log->fname, "a+");
if (log->fp == NULL) {
log->state = LOG_STATE_DISABLED;
putlog(LOG_MISC, "*", _("Failed to open log file: %s"), log->fname);
putlog(LOG_MISC, "*", _(" Check if directory (if any) exists and is read- and writeable."));
continue;
}
}
/* Now output to the file. */
fprintf(log->fp, "%s%s\n", ts, text);
}
if (!backgrd || use_stderr) {
if (terminal_mode) {
/* check if HQ is on console. If yes we disable
* output to stdout since otherwise everything would
* be printed out twice. */
if (!terminal_enabled) {
terminal_enabled = (partymember_lookup(TERMINAL_NICK, NULL, -1) != NULL);
}
if (terminal_enabled)
return 0;
}
fprintf (stdout, "%s %s%s\n", chan, ts, text);
}
return(0);
}
