// -----[ _ipip_proto_dump_msg ]-------------------------------------
static void _ipip_proto_dump_msg(gds_stream_t * stream, net_msg_t * msg)
{
net_msg_t * encap_msg= (net_msg_t *) msg->payload;
stream_printf(stream, "msg:[");
message_dump(stream, encap_msg);
stream_printf(stream, "]");
}
void file_system_no_more_free_event(u32 len)
{
assert(len == 0);
#if ENABLE_GPS_ERROR_LOGGING
u32 msg_len = debug::log_to_string(error_buffer, debug::error, "Filesystem had no more free blocks");
message_dump(error_buffer, msg_len, log_protocol, raw_log_file.get_stream());
#endif
}
void file_system_write_queue_full_event(u32 len)
{
assert(len == 0);
#if ENABLE_GPS_ERROR_LOGGING
u32 msg_len = debug::log_to_string(error_buffer, debug::error, "Filesystem write queue was full");
message_dump(error_buffer, msg_len, log_protocol, raw_log_file.get_stream());
#endif
}
static int _debug_for_each(gds_stream_t * stream, void * context,
char format)
{
va_list * ap= (va_list*) context;
net_node_t * node;
net_addr_t addr;
net_msg_t * msg;
net_iface_t * iface;
int error;
switch (format) {
case 'a':
addr= va_arg(*ap, net_addr_t);
ip_address_dump(stream, addr);
break;
case 'e':
error= va_arg(*ap, int);
network_perror(stream, error);
break;
case 'i':
iface= va_arg(*ap, net_iface_t *);
net_iface_dump_id(stream, iface);
break;
case 'm':
msg= va_arg(*ap, net_msg_t *);
stream_printf(stream, "[");
message_dump(stream, msg);
stream_printf(stream, "]");
break;
case 'n':
node= va_arg(*ap, net_node_t *);
node_dump_id(stream, node);
break;
}
return 0;
}
void run()
{
CTL_EVENT_SET_t event_received;
// request the battery level periodically
msg::payload::enqueue_time_event batt_request;
batt_request.message = msg::id::battery_level_request;
batt_request.dest = msg::src::aux;
batt_request.type = msg::payload::time_event_types::repeating;
batt_request.next_time_ms = 0;
batt_request.period = 10000;
get_central().send_message(msg::src::time_queue, msg::id::enqueue_time_event, sizeof(batt_request), reinterpret_cast<u8*>(&batt_request));
// request the board serial number ( == RF MAC address)
get_central().send_message(msg::src::aux, msg::id::serial_number_request);
// ensure the files are created before we get into the loop as those operations can take some time
#if ENABLE_RAW_LOGGING
raw_log_file.get_stream();
#endif
#if ENABLEEPHEMERIS_LOGGING
eph_mgr.touch_files();
#endif
#if ENABLE_ROVER_PROCESSOR
rover_pda_link.open();
#endif
#if ENABLE_GPS_UART_LOGGING
gps_uart_logger.start_logging();
s32 gnss_status = gnss_com_ctrl.init(&gps_uart_logger, &eph_mgr, uart_baud_rates::gps, gnss_dynamic_mode);
#else
s32 gnss_status = gnss_com_ctrl.init(&get_gps_uart_io(), &eph_mgr, uart_baud_rates::gps, gnss_dynamic_mode);
#endif
assert(0 == gnss_status);
#if ENABLE_ROVER_PROCESSOR
msg_handler::proxdet* prox_handlers[2];
prox_handlers[0] = gps_ctrl.get_prox_handler();
prox_handlers[1] = &prox_handler;
#endif
CTL_EVENT_SET_t listened_events = gps_receive_mask | gps_error_mask | messages_mask
#if ENABLE_ROVER_PROCESSOR
| rf_receive_mask | rf_error_mask | pda_mask_0 | pda_mask_1
#endif
;
bool done = false;
while (!done)
{
if (get_central().system_shutdown_requested())
{
// this task can get really busy and has a high priority, which may hamper normal shutdown. detect shutdown and disable the event in order to let lower priority tasks run.
listened_events = messages_mask;
}
// wait for input from the gnss uart (this is setup in the master init_modules function)
event_received = ctl_events_wait(CTL_EVENT_WAIT_ANY_EVENTS_WITH_AUTO_CLEAR, &gnss_receive_event, listened_events, CTL_TIMEOUT_INFINITE, 0);
done = observe_all_messages(event_received);
#if ENABLE_ROVER_PROCESSOR
if (event_received & (rf_receive_mask | gps_receive_mask))
{
s32 status = rf_ctrl.rx_rover(gps_ctrl.get_next_base_data(), prox_handlers, 2);
while (status > 0)
{
if (1 == status)
{
gps_ctrl.process_base_data();
#if ENABLE_RF_DATA_LOGGING
raw_base_dump(*gps_ctrl.get_current_base_data(), log_protocol, raw_log_file.get_stream());
#endif
}
status = rf_ctrl.rx_rover(gps_ctrl.get_next_base_data(), prox_handlers, 2);
}
}
if (event_received & rf_error_mask)
{
#if ENABLE_GPS_ERROR_LOGGING
u8 err_code = get_rf_uart_io().get_last_error();
u32 len = debug::log_to_string(error_buffer, debug::error, "RF uart error 0x%X", err_code);
message_dump(error_buffer, len, log_protocol, raw_log_file.get_stream());
#endif
}
#endif
if (event_received & gps_receive_mask)
{
while (gnss_com_ctrl.gnssrx_getnav(gps_ctrl.get_next_gnss_navdata(), gps_ctrl.get_next_gnss_rawdata()))
{
#if ENABLE_GPS_DATA_LOGGING
gnss_rawdata_dump(*gps_ctrl.get_next_gnss_rawdata(), log_protocol, raw_log_file.get_stream());
if (gps_ctrl.get_next_gnss_navdata()->datavalid)
gnss_navdata_dump(*gps_ctrl.get_next_gnss_navdata(), log_protocol, raw_log_file.get_stream());
#endif
#if ENABLE_GPS_ERROR_LOGGING
s32 gnss_error_code = gnss_com_ctrl.gnssrx_geterror();
if (gnss_error_code)
{
u32 len = debug::log_to_string(error_buffer, debug::error, "GNSS COM error 0x%X", gnss_error_code);
message_dump(error_buffer, len, log_protocol, raw_log_file.get_stream());
}
#endif
bool new_nav_data;
#if ENABLE_BASE_PROCESSOR
s32 status = gps_ctrl.process_gnss_data(&bd, &new_nav_data);
#endif
#if ENABLE_ROVER_PROCESSOR
s32 status = gps_ctrl.process_gnss_data(&new_nav_data);
rover_pda_link.set_rover_status(status);
#endif
if (new_nav_data)
{
get_rt_clock().set_real_time(gps_ctrl.get_current_gnss_navdata().utc,
gps_ctrl.get_current_gnss_navdata().tow);
#if ENABLE_BASE_PROCESSOR
rf_ctrl.tx_base(&bd, fresh_batt_level, status);
#endif
}
#if ENABLE_BASE_PROCESSOR && ENABLE_RF_DATA_LOGGING
raw_base_dump(bd, log_protocol, raw_log_file.get_stream());
#endif
#if ENABLE_ROVER_PROCESSOR
u32 flags = rover::pda_link::raw_data;
if (new_nav_data)
flags |= rover::pda_link::nav_data;
rover_pda_link.update(flags);
#endif
#if ENABLE_CONSOLE
update_debug_status();
#endif
if (get_central().system_shutdown_requested())
{
// this task can get really busy and has a high priority, which may hamper normal shutdown. detect shutdown and disable the event in order to let lower priority tasks run.
listened_events = messages_mask;
break;
}
}
}
if (event_received & gps_error_mask)
{
#if ENABLE_GPS_ERROR_LOGGING
u8 err_code = get_gps_uart_io().get_last_error();
u32 len = debug::log_to_string(error_buffer, debug::error, "GPS uart error 0x%X", err_code);
message_dump(error_buffer, len, log_protocol, raw_log_file.get_stream());
#endif
}
#if ENABLE_ROVER_PROCESSOR
if (event_received & (pda_mask_0 | pda_mask_1))
{
rover_pda_link.process_pda_requests();
rover_pda_link.output_console();
}
#endif
}
#if ENABLE_EPHEMERIS_LOGGING
eph_mgr.close_files(); // writes to a log file the new ephemeris data we have received
#endif
#if ENABLE_RAW_LOGGING
raw_log_file.close();
#endif
#if ENABLE_ROVER_PROCESSOR
rover_pda_link.close();
#endif
get_int_ctrl().disable_interrupt(lpc3230::interrupt::id::gps_time_pulse);
}
