WIP: parameter export hacks

Signed-off-by: Alex Mikhalev <alex@corvus-robotics.com>

.ci/Jenkinsfile-hardware

@@ -1030,6 +1030,7 @@ void statusFTDI() {
   sh './Tools/HIL/run_nsh_cmd.py --device `find /dev/serial -name *usb-*` --cmd "listener sensor_accel_fifo"'
   sh './Tools/HIL/run_nsh_cmd.py --device `find /dev/serial -name *usb-*` --cmd "listener sensor_baro"'
   sh './Tools/HIL/run_nsh_cmd.py --device `find /dev/serial -name *usb-*` --cmd "listener sensor_combined"'
+  sh './Tools/HIL/run_nsh_cmd.py --device `find /dev/serial -name *usb-*` --cmd "listener sensor_gps"'
   sh './Tools/HIL/run_nsh_cmd.py --device `find /dev/serial -name *usb-*` --cmd "listener sensor_gyro"'
   sh './Tools/HIL/run_nsh_cmd.py --device `find /dev/serial -name *usb-*` --cmd "listener sensor_gyro_fifo"'
   sh './Tools/HIL/run_nsh_cmd.py --device `find /dev/serial -name *usb-*` --cmd "listener sensor_mag"'
@@ -1041,6 +1042,7 @@ void statusFTDI() {
   sh './Tools/HIL/run_nsh_cmd.py --device `find /dev/serial -name *usb-*` --cmd "listener vehicle_angular_acceleration"'
   sh './Tools/HIL/run_nsh_cmd.py --device `find /dev/serial -name *usb-*` --cmd "listener vehicle_angular_velocity"'
   sh './Tools/HIL/run_nsh_cmd.py --device `find /dev/serial -name *usb-*` --cmd "listener vehicle_attitude"'
+  sh './Tools/HIL/run_nsh_cmd.py --device `find /dev/serial -name *usb-*` --cmd "listener vehicle_gps_position"'
   sh './Tools/HIL/run_nsh_cmd.py --device `find /dev/serial -name *usb-*` --cmd "listener vehicle_imu"'
   sh './Tools/HIL/run_nsh_cmd.py --device `find /dev/serial -name *usb-*` --cmd "listener vehicle_imu_status"'
   sh './Tools/HIL/run_nsh_cmd.py --device `find /dev/serial -name *usb-*` --cmd "listener vehicle_local_position"'

.vscode/settings.json

@@ -137,5 +137,8 @@
         "workbench.settings.enableNaturalLanguageSearch": false,
         "yaml.schemas": {
                 "${workspaceFolder}/validation/module_schema.yaml": "${workspaceFolder}/src/modules/*/module.yaml"
-        }
+        },
+        "python.autoComplete.extraPaths": [
+                "/opt/ros/foxy/lib/python3.8/site-packages"
+        ]
 }

README.md

@@ -17,7 +17,7 @@ PX4 is highly portable, OS-independent and supports Linux, NuttX and QuRT out of
   * [VTOL](https://docs.px4.io/master/en/frames_vtol/)
   * [Autogyro](https://docs.px4.io/master/en/frames_autogyro/)
   * [Rover](https://docs.px4.io/master/en/frames_rover/)
-  * many more experimental types (Blimps, Boats, Submarines, Autogyros, etc)
+  * many more experimental types (Blimps, Boats, Submarines, High altitude balloons, etc)
 * Releases: [Downloads](https://github.com/PX4/PX4-Autopilot/releases)
 
 

boards/cubepilot/cubeorange/console.cmake

@@ -43,6 +43,7 @@ px4_add_board(
 		#pca9685_pwm_out
 		power_monitor/ina226
 		#protocol_splitter
+		pwm_input
 		pwm_out_sim
 		pwm_out
 		px4io

boards/cubepilot/cubeorange/default.cmake

@@ -44,6 +44,7 @@ px4_add_board(
 		pca9685_pwm_out
 		power_monitor/ina226
 		#protocol_splitter
+		pwm_input
 		pwm_out_sim
 		pwm_out
 		px4io

boards/cubepilot/cubeorange/src/board_config.h

@@ -115,6 +115,11 @@
 #define GPIO_TONE_ALARM_IDLE    GPIO_BUZZER_1
 #define GPIO_TONE_ALARM         GPIO_TIM2_CH1OUT_2
 
+/* PWM input driver. Use FMU AUX5 pins attached to timer4 channel 2 */
+#define PWMIN_TIMER                       4
+#define PWMIN_TIMER_CHANNEL    /* T4C2 */ 2
+#define GPIO_PWM_IN            /* PD13 */ GPIO_TIM4_CH2IN_2
+
 /* USB
  *  OTG FS: PA9  OTG_FS_VBUS VBUS sensing
  */

msg/sensor_gps.msg

@@ -2,6 +2,8 @@
 # the field 'timestamp' is for the position & velocity (microseconds)
 uint64 timestamp		# time since system start (microseconds)
 
+uint32 device_id                # unique device ID for the sensor that does not change between power cycles
+
 int32 lat			# Latitude in 1E-7 degrees
 int32 lon			# Longitude in 1E-7 degrees
 int32 alt			# Altitude in 1E-3 meters above MSL, (millimetres)

platforms/nuttx/src/px4/common/board_crashdump.c

@@ -369,7 +369,7 @@ __EXPORT void board_crashdump(uintptr_t currentsp, FAR void *tcb, FAR const char
 		pdump->info.flags |= eInvalidUserStackPtr;
 	}
 
-	int rv = px4_savepanic(HARDFAULT_FILENO, (uint8_t *)pdump, sizeof(fullcontext_s));
+	int rv = stm32_bbsram_savepanic(HARDFAULT_FILENO, (uint8_t *)pdump, sizeof(fullcontext_s));
 
 	/* Test if memory got wiped because of using _sdata */
 

platforms/nuttx/src/px4/nxp/k66/include/px4_arch/micro_hal.h

@@ -87,10 +87,6 @@ __BEGIN_DECLS
 #define PX4_CPU_UUID_WORD32_FORMAT_SIZE         (PX4_CPU_UUID_WORD32_LENGTH-1+(2*PX4_CPU_UUID_BYTE_LENGTH)+1)
 #define PX4_CPU_MFGUID_FORMAT_SIZE              ((2*PX4_CPU_MFGUID_BYTE_LENGTH)+1)
 
-#define kinetis_bbsram_savepanic(fileno, context, length) (0) // todo:Not implemented yet
-
-#define px4_savepanic(fileno, context, length)   kinetis_bbsram_savepanic(fileno, context, length)
-
 /* bus_num is zero based on kinetis and must be translated from the legacy one based */
 
 #define PX4_BUS_OFFSET       1                  /* Kinetis buses are 0 based and adjustment is needed */

platforms/nuttx/src/px4/nxp/rt106x/include/px4_arch/micro_hal.h

@@ -82,10 +82,6 @@ __BEGIN_DECLS
 #define PX4_CPU_UUID_WORD32_FORMAT_SIZE         (PX4_CPU_UUID_WORD32_LENGTH-1+(2*PX4_CPU_UUID_BYTE_LENGTH)+1)
 #define PX4_CPU_MFGUID_FORMAT_SIZE              ((2*PX4_CPU_MFGUID_BYTE_LENGTH)+1)
 
-#define imxrt_bbsram_savepanic(fileno, context, length) (0) // todo:Not implemented yet
-
-#define px4_savepanic(fileno, context, length)   imxrt_bbsram_savepanic(fileno, context, length)
-
 /* bus_num is 1 based on imx and must be translated from the legacy one based */
 
 #define PX4_BUS_OFFSET       0                  /* imxrt buses are 1 based no adjustment needed */

platforms/nuttx/src/px4/nxp/s32k14x/include/px4_arch/micro_hal.h

@@ -89,10 +89,6 @@ __BEGIN_DECLS
 #define PX4_CPU_UUID_WORD32_FORMAT_SIZE         (PX4_CPU_UUID_WORD32_LENGTH-1+(2*PX4_CPU_UUID_BYTE_LENGTH)+1)
 #define PX4_CPU_MFGUID_FORMAT_SIZE              ((2*PX4_CPU_MFGUID_BYTE_LENGTH)+1)
 
-#define s32k1xx_bbsram_savepanic(fileno, context, length) (0) // todo:Not implemented yet
-
-#define px4_savepanic(fileno, context, length)   s32k1xx_bbsram_savepanic(fileno, context, length)
-
 /* bus_num is zero based on s32k1xx and must be translated from the legacy one based */
 
 #define PX4_BUS_OFFSET       1                  /* s32k1xx buses are 0 based and adjustment is needed */

platforms/nuttx/src/px4/stm/stm32_common/include/px4_arch/micro_hal.h

@@ -88,8 +88,6 @@ __BEGIN_DECLS
 #define PX4_CPU_UUID_WORD32_FORMAT_SIZE         (PX4_CPU_UUID_WORD32_LENGTH-1+(2*PX4_CPU_UUID_BYTE_LENGTH)+1)
 #define PX4_CPU_MFGUID_FORMAT_SIZE              ((2*PX4_CPU_MFGUID_BYTE_LENGTH)+1)
 
-#define px4_savepanic(fileno, context, length)  stm32_bbsram_savepanic(fileno, context, length)
-
 #define PX4_BUS_OFFSET       0                  /* STM buses are 1 based no adjustment needed */
 #define px4_spibus_initialize(bus_num_1based)   stm32_spibus_initialize(bus_num_1based)
 

src/drivers/drv_sensor.h

@@ -177,6 +177,22 @@
 #define DRV_DIST_DEVTYPE_SIM 0x9a
 #define DRV_DIST_DEVTYPE_SRF05 0x9b
 
+
+#define DRV_GPS_DEVTYPE_ASHTECH 0xA0
+#define DRV_GPS_DEVTYPE_EMLID_REACH 0xA1
+#define DRV_GPS_DEVTYPE_FEMTOMES 0xA2
+#define DRV_GPS_DEVTYPE_MTK 0xA3
+#define DRV_GPS_DEVTYPE_SBF 0xA4
+#define DRV_GPS_DEVTYPE_UBX     0xA5
+#define DRV_GPS_DEVTYPE_UBX_6   0xA6
+#define DRV_GPS_DEVTYPE_UBX_7   0xA7
+#define DRV_GPS_DEVTYPE_UBX_8   0xA8
+#define DRV_GPS_DEVTYPE_UBX_9   0xA9
+#define DRV_GPS_DEVTYPE_UBX_F9P 0xAA
+
+#define DRV_GPS_DEVTYPE_SIM 0xAF
+
+
 #define DRV_DEVTYPE_UNUSED		0xff
 
 #endif /* _DRV_SENSOR_H */

src/drivers/gps/gps.cpp

@@ -47,6 +47,8 @@
 
 #include <termios.h>
 
+#include <drivers/drv_sensor.h>
+#include <lib/drivers/device/Device.hpp>
 #include <lib/parameters/param.h>
 #include <mathlib/mathlib.h>
 #include <matrix/math.hpp>
@@ -91,7 +93,7 @@ struct GPS_Sat_Info {
 static constexpr int TASK_STACK_SIZE = 1760;
 
 
-class GPS : public ModuleBase<GPS>
+class GPS : public ModuleBase<GPS>, public device::Device
 {
 public:
 
@@ -260,6 +262,7 @@ extern "C" __EXPORT int gps_main(int argc, char *argv[]);
 
 GPS::GPS(const char *path, gps_driver_mode_t mode, GPSHelper::Interface interface, bool enable_sat_info,
 	 Instance instance, unsigned configured_baudrate) :
+	Device(MODULE_NAME),
 	_configured_baudrate(configured_baudrate),
 	_mode(mode),
 	_interface(interface),
@@ -280,6 +283,16 @@ GPS::GPS(const char *path, gps_driver_mode_t mode, GPSHelper::Interface interfac
 		memset(_p_report_sat_info, 0, sizeof(*_p_report_sat_info));
 	}
 
+	if (_interface == GPSHelper::Interface::UART) {
+		set_device_bus_type(device::Device::DeviceBusType::DeviceBusType_SERIAL);
+
+		char c = _port[strlen(_port) - 1]; // last digit of path (eg /dev/ttyS2)
+		set_device_bus(atoi(&c));
+
+	} else if (_interface == GPSHelper::Interface::SPI) {
+		set_device_bus_type(device::Device::DeviceBusType::DeviceBusType_SPI);
+	}
+
 	if (_mode == GPS_DRIVER_MODE_NONE) {
 		// use parameter to select mode if not provided via CLI
 		char protocol_param_name[16];
@@ -345,7 +358,7 @@ int GPS::callback(GPSCallbackType type, void *data1, int data2, void *user)
 	case GPSCallbackType::writeDeviceData:
 		gps->dumpGpsData((uint8_t *)data1, (size_t)data2, true);
 
-		return write(gps->_serial_fd, data1, (size_t)data2);
+		return ::write(gps->_serial_fd, data1, (size_t)data2);
 
 	case GPSCallbackType::setBaudrate:
 		return gps->setBaudrate(data2);
@@ -417,7 +430,7 @@ int GPS::pollOrRead(uint8_t *buf, size_t buf_length, int timeout)
 #ifdef __PX4_NUTTX
 			int err = 0;
 			int bytes_available = 0;
-			err = ioctl(_serial_fd, FIONREAD, (unsigned long)&bytes_available);
+			err = ::ioctl(_serial_fd, FIONREAD, (unsigned long)&bytes_available);
 
 			if (err != 0 || bytes_available < (int)character_count) {
 				px4_usleep(sleeptime);
@@ -662,14 +675,14 @@ GPS::run()
 
 	if (_interface == GPSHelper::Interface::SPI) {
 		int spi_speed = 1000000; // make sure the bus speed is not too high (required on RPi)
-		int status_value = ioctl(_serial_fd, SPI_IOC_WR_MAX_SPEED_HZ, &spi_speed);
+		int status_value = ::ioctl(_serial_fd, SPI_IOC_WR_MAX_SPEED_HZ, &spi_speed);
 
 		if (status_value < 0) {
 			PX4_ERR("SPI_IOC_WR_MAX_SPEED_HZ failed for %s (%d)", _port, errno);
 			return;
 		}
 
-		status_value = ioctl(_serial_fd, SPI_IOC_RD_MAX_SPEED_HZ, &spi_speed);
+		status_value = ::ioctl(_serial_fd, SPI_IOC_RD_MAX_SPEED_HZ, &spi_speed);
 
 		if (status_value < 0) {
 			PX4_ERR("SPI_IOC_RD_MAX_SPEED_HZ failed for %s (%d)", _port, errno);
@@ -743,19 +756,23 @@ GPS::run()
 		case GPS_DRIVER_MODE_UBX:
 			_helper = new GPSDriverUBX(_interface, &GPS::callback, this, &_report_gps_pos, _p_report_sat_info,
 						   gps_ubx_dynmodel, heading_offset, ubx_mode);
+			set_device_type(DRV_GPS_DEVTYPE_UBX);
 			break;
 #ifndef CONSTRAINED_FLASH
 
 		case GPS_DRIVER_MODE_MTK:
 			_helper = new GPSDriverMTK(&GPS::callback, this, &_report_gps_pos);
+			set_device_type(DRV_GPS_DEVTYPE_MTK);
 			break;
 
 		case GPS_DRIVER_MODE_ASHTECH:
 			_helper = new GPSDriverAshtech(&GPS::callback, this, &_report_gps_pos, _p_report_sat_info, heading_offset);
+			set_device_type(DRV_GPS_DEVTYPE_ASHTECH);
 			break;
 
 		case GPS_DRIVER_MODE_EMLIDREACH:
 			_helper = new GPSDriverEmlidReach(&GPS::callback, this, &_report_gps_pos, _p_report_sat_info);
+			set_device_type(DRV_GPS_DEVTYPE_EMLID_REACH);
 			break;
 #endif // CONSTRAINED_FLASH
 
@@ -779,6 +796,37 @@ GPS::run()
 
 				/* GPS is obviously detected successfully, reset statistics */
 				_helper->resetUpdateRates();
+
+				// populate specific ublox model
+				if (get_device_type() == DRV_GPS_DEVTYPE_UBX) {
+					GPSDriverUBX *driver_ubx = (GPSDriverUBX *)_helper;
+
+					switch (driver_ubx->board()) {
+					case GPSDriverUBX::Board::u_blox6:
+						set_device_type(DRV_GPS_DEVTYPE_UBX_6);
+						break;
+
+					case GPSDriverUBX::Board::u_blox7:
+						set_device_type(DRV_GPS_DEVTYPE_UBX_7);
+						break;
+
+					case GPSDriverUBX::Board::u_blox8:
+						set_device_type(DRV_GPS_DEVTYPE_UBX_8);
+						break;
+
+					case GPSDriverUBX::Board::u_blox9:
+						set_device_type(DRV_GPS_DEVTYPE_UBX_9);
+						break;
+
+					case GPSDriverUBX::Board::u_blox9_F9P:
+						set_device_type(DRV_GPS_DEVTYPE_UBX_F9P);
+						break;
+
+					default:
+						set_device_type(DRV_GPS_DEVTYPE_UBX);
+						break;
+					}
+				}
 			}
 
 			int helper_ret;
@@ -987,6 +1035,8 @@ void
 GPS::publish()
 {
 	if (_instance == Instance::Main || _is_gps_main_advertised.load()) {
+		_report_gps_pos.device_id = get_device_id();
+
 		_report_gps_pos_pub.publish(_report_gps_pos);
 		// Heading/yaw data can be updated at a lower rate than the other navigation data.
 		// The uORB message definition requires this data to be set to a NAN if no new valid data is available.

src/drivers/uavcan/sensors/gnss.cpp

@@ -64,6 +64,8 @@ UavcanGnssBridge::UavcanGnssBridge(uavcan::INode &node) :
 	for (uint8_t i = 0; i < _max_channels; i++) {
 		_channel_using_fix2[i] = false;
 	}
+
+	set_device_type(DRV_GPS_DEVTYPE_UAVCAN);
 }
 
 UavcanGnssBridge::~UavcanGnssBridge()
@@ -282,6 +284,7 @@ void UavcanGnssBridge::process_fixx(const uavcan::ReceivedDataStructure<FixType>
 				    const bool valid_pos_cov, const bool valid_vel_cov)
 {
 	sensor_gps_s report{};
+	report.device_id = get_device_id();
 
 	/*
 	 * FIXME HACK

src/drivers/uavcan/sensors/sensor_bridge.cpp

@@ -114,6 +114,7 @@ UavcanSensorBridgeBase::publish(const int node_id, const void *report)
 
 		// update device id as we now know our device node_id
 		_device_id.devid_s.address = static_cast<uint8_t>(node_id);
+		_device_id.devid_s.bus_type = DeviceBusType::DeviceBusType_UAVCAN;
 
 		// Publish to the appropriate topic, abort on failure
 		channel->orb_advert = orb_advertise_multi(_orb_topic, report, &channel->instance);

src/lib/parameters/CMakeLists.txt

@@ -154,7 +154,7 @@ if (NOT "${PX4_BOARD}" MATCHES "px4_io")
 	)
 
 	target_link_libraries(parameters PRIVATE perf tinybson px4_layer)
-	target_compile_definitions(parameters PRIVATE -DMODULE_NAME="parameters")
+	target_compile_definitions(parameters PRIVATE -DMODULE_NAME="parameters" -DDEBUG_BUILD)
 	target_compile_options(parameters
 		PRIVATE
 			-Wno-cast-align		# TODO: fix and enable

src/lib/parameters/flashparams/flashparams.cpp

@@ -117,7 +117,7 @@ param_export_internal(bool only_unsaved, param_filter_func filter)
 		case PARAM_TYPE_INT32:
 			i = s->val.i;
 
-			if (bson_encoder_append_int(&encoder, param_name(s->param), i)) {
+			if (bson_encoder_append_int32(&encoder, param_name(s->param), i)) {
 				debug("BSON append failed for '%s'", param_name(s->param));
 				goto out;
 			}

src/lib/parameters/parameters.cpp

@@ -1009,6 +1009,8 @@ int param_reset_no_notification(param_t param) { return param_reset_internal(par
 static void
 param_reset_all_internal(bool auto_save)
 {
+	PX4_INFO("param_reset_all_internal");
+
 	param_lock_writer();
 
 	if (param_values != nullptr) {
@@ -1131,33 +1133,42 @@ int param_save_default()
 		return res;
 	}
 
-	/* write parameters to temp file */
-	int fd = PARAM_OPEN(filename, O_WRONLY | O_CREAT, PX4_O_MODE_666);
-
-	if (fd < 0) {
-		PX4_ERR("failed to open param file: %s", filename);
-
-		return PX4_ERROR;
-	}
-
 	int attempts = 5;
 
 	while (res != OK && attempts > 0) {
-		res = param_export(fd, false, nullptr);
-		attempts--;
 
-		if (res != PX4_OK) {
-			PX4_ERR("param_export failed, retrying %d", attempts);
-			lseek(fd, 0, SEEK_SET); // jump back to the beginning of the file
+		/* write parameters to temp file */
+		int fd = ::open(filename, O_WRONLY | O_CREAT, PX4_O_MODE_666);
+
+		if (fd >= 0) {
+			PX4_DEBUG("param export %d/5", attempts - 4);
+			res = param_export(fd, false, nullptr);
+			::close(fd);
+
+			if (res == PX4_OK) {
+				fd = -1;
+
+				static const char *backup_file = PX4_ROOTFSDIR"/eeprom/parameters_backup.bson";
+				fd = ::open(backup_file, O_WRONLY | O_CREAT, PX4_O_MODE_666);
+				res = param_export(fd, false, nullptr);
+				::close(fd);
+
+			} else {
+				PX4_ERR("param_export failed, retrying %d", attempts);
+			}
+
+		} else {
+			PX4_ERR("failed to open param file: %s", filename);
+			return PX4_ERROR;
 		}
+
+		attempts--;
 	}
 
 	if (res != OK) {
 		PX4_ERR("failed to write parameters to file: %s", filename);
 	}
 
-	PARAM_CLOSE(fd);
-
 	return res;
 }
 
@@ -1200,20 +1211,19 @@ param_load_default()
 int
 param_export(int fd, bool only_unsaved, param_filter_func filter)
 {
-	int	result = -1;
 	perf_begin(param_export_perf);
 
 	if (fd < 0) {
 		param_lock_writer();
 		// flash_param_save() will take the shutdown lock
-		result = flash_param_save(only_unsaved, filter);
+		int result = flash_param_save(only_unsaved, filter);
 		param_unlock_writer();
 		perf_end(param_export_perf);
 		return result;
 	}
 
-	param_wbuf_s *s = nullptr;
-	struct bson_encoder_s encoder;
+
+
 
 	int shutdown_lock_ret = px4_shutdown_lock();
 
@@ -1226,16 +1236,31 @@ param_export(int fd, bool only_unsaved, param_filter_func filter)
 
 	param_lock_reader();
 
+	bson_encoder_s encoder{};
 	uint8_t bson_buffer[256];
 	bson_encoder_init_buf_file(&encoder, fd, &bson_buffer, sizeof(bson_buffer));
 
+	int result = PX4_ERROR;
+	param_wbuf_s *s = nullptr;
+	uint32_t export_crc32 = 0;
+	uint32_t export_count_int32 = 0;
+	uint32_t export_count_double = 0;
+	size_t total_size = sizeof(int32_t);
+
 	/* no modified parameters -> we are done */
 	if (param_values == nullptr) {
-		result = 0;
+		result = PX4_OK;
 		goto out;
 	}
 
-	while ((s = (struct param_wbuf_s *)utarray_next(param_values, s)) != nullptr) {
+	while ((s = (param_wbuf_s *)utarray_next(param_values, s)) != nullptr) {
+
+		if (encoder.dead) {
+			PX4_ERR("bson encoder dead!");
+			result = PX4_ERROR;
+			goto out;
+		}
+
 		/*
 		 * If we are only saving values changed since last save, and this
 		 * one hasn't, then skip it
@@ -1275,28 +1300,39 @@ param_export(int fd, bool only_unsaved, param_filter_func filter)
 
 		s->unsaved = false;
 
-		const char *name = param_name(s->param);
-		const size_t size = param_size(s->param);
-
 		/* append the appropriate BSON type object */
 		switch (param_type(s->param)) {
-
 		case PARAM_TYPE_INT32: {
+				const char *name = param_name(s->param);
 				const int32_t i = s->val.i;
-				PX4_DEBUG("exporting: %s (%d) size: %lu val: %d", name, s->param, (long unsigned int)size, i);
+				size_t bson_size = sizeof(int8_t) + strlen(name) + 1 + sizeof(i);
+				total_size += bson_size;
+				PX4_DEBUG("exporting: %s (%d) (name size: %d) size: %lu val: %d - size: %d, total_size: %d", name, s->param,
+					  strlen(name) + 1, (long unsigned int)param_size(s->param), i, bson_size, total_size);
 
-				if (bson_encoder_append_int(&encoder, name, i)) {
+				if (bson_encoder_append_int32(&encoder, name, i) == 0) {
+					export_count_int32++;
+
+				} else {
 					PX4_ERR("BSON append failed for '%s'", name);
 					goto out;
 				}
+
 			}
 			break;
 
 		case PARAM_TYPE_FLOAT: {
+				const char *name = param_name(s->param);
 				const double f = (double)s->val.f;
-				PX4_DEBUG("exporting: %s (%d) size: %lu val: %.3f", name, s->param, (long unsigned int)size, (double)f);
+				size_t bson_size = sizeof(int8_t) + strlen(name) + 1 + sizeof(f);
+				total_size += bson_size;
+				PX4_DEBUG("exporting: %s (%d) (name size: %d) size: %lu val: %.3f - size: %d, total_size: %d", name, s->param,
+					  strlen(name) + 1, (long unsigned int)param_size(s->param), (double)f, bson_size, total_size);
 
-				if (bson_encoder_append_double(&encoder, name, f)) {
+				if (bson_encoder_append_double(&encoder, name, f) == 0) {
+					export_count_double++;
+
+				} else {
 					PX4_ERR("BSON append failed for '%s'", name);
 					goto out;
 				}
@@ -1307,16 +1343,29 @@ param_export(int fd, bool only_unsaved, param_filter_func filter)
 			PX4_ERR("unrecognized parameter type");
 			goto out;
 		}
+
+		const char *name = param_name(s->param);
+		const void *val = &(s->val);
+		export_crc32 = crc32part((const uint8_t *)name, strlen(name), export_crc32);
+		export_crc32 = crc32part((const uint8_t *)val, param_size(s->param), export_crc32);
 	}
 
-	result = 0;
+	result = PX4_OK;
 
 out:
 
-	if (result == 0) {
+	if (result == PX4_OK) {
+		bson_encoder_append_int32(&encoder, "PX4_PARAMETER_CRC32", export_crc32);
+		bson_encoder_append_int32(&encoder, "PX4_PARAMETER_COUNT_INT32", export_count_int32);
+		bson_encoder_append_int32(&encoder, "PX4_PARAMETER_COUNT_DOUBLE", export_count_double);
+
+		PX4_DEBUG("bson_encoder_fini");
+
 		if (bson_encoder_fini(&encoder) != PX4_OK) {
 			PX4_ERR("bson encoder finish failed");
 		}
+
+		PX4_DEBUG("BSON final size = %d, crc32: %X", encoder.total_written_size, export_crc32);
 	}
 
 	param_unlock_reader();
@@ -1373,16 +1422,22 @@ param_import_callback(bson_decoder_t decoder, void *priv, bson_node_t node)
 
 	switch (node->type) {
 	case BSON_INT32: {
-			if (param_type(param) != PARAM_TYPE_INT32) {
-				PX4_WARN("unexpected type for %s", node->name);
-				result = 1; // just skip this entry
-				goto out;
+			if (strcmp(node->name, "PX4_PARAMETER_CRC32") == 0) {
+				int32_t crc32 = node->i;
+				PX4_INFO("%s = %X", node->name, crc32);
+
+			} else {
+				if (param_type(param) != PARAM_TYPE_INT32) {
+					PX4_WARN("unexpected type for %s", node->name);
+					result = 1; // just skip this entry
+					goto out;
+				}
+
+				i = node->i;
+				v = &i;
+
+				PX4_DEBUG("Imported %s with value %d", param_name(param), i);
 			}
-
-			i = node->i;
-			v = &i;
-
-			PX4_DEBUG("Imported %s with value %d", param_name(param), i);
 		}
 		break;
 
@@ -1405,6 +1460,11 @@ param_import_callback(bson_decoder_t decoder, void *priv, bson_node_t node)
 		goto out;
 	}
 
+	{
+		decoder->import_scratch = crc32part((const uint8_t *)node->name, strlen(node->name), decoder->import_scratch);
+		decoder->import_scratch = crc32part((const uint8_t *)v, param_size(param), decoder->import_scratch);
+	}
+
 	if (param_set_internal(param, v, state->mark_saved, true)) {
 		PX4_DEBUG("error setting value for '%s'", node->name);
 		goto out;
@@ -1420,6 +1480,11 @@ out:
 static int
 param_import_internal(int fd, bool mark_saved)
 {
+
+	off_t fsize = lseek(fd, 0, SEEK_END);
+	PX4_DEBUG("param file size = %d", fsize);
+	lseek(fd, 0, SEEK_SET);
+
 	bson_decoder_s decoder;
 	param_import_state state;
 	int result = -1;
@@ -1434,7 +1499,9 @@ param_import_internal(int fd, bool mark_saved)
 	do {
 		result = bson_decoder_next(&decoder);
 
-	} while (result > 0);
+	} while (result > 0 && !decoder.dead);
+
+	PX4_DEBUG("bson decode finished total bytes: %d, crc32: %X", decoder.total_bytes_imported, decoder.import_scratch);
 
 	return result;
 }

src/lib/parameters/parameters_shmem.cpp

@@ -1149,7 +1149,7 @@ param_export(int fd, bool only_unsaved, param_filter_func filter)
 
 				PX4_DEBUG("exporting: %s (%d) size: %d val: %d", name, s->param, size, i);
 
-				if (bson_encoder_append_int(&encoder, name, i)) {
+				if (bson_encoder_append_int32(&encoder, name, i)) {
 					PX4_ERR("BSON append failed for '%s'", name);
 					goto out;
 				}

src/lib/parameters/tinybson/CMakeLists.txt

@@ -33,5 +33,5 @@
 
 add_library(tinybson tinybson.cpp)
 target_compile_definitions(tinybson PRIVATE -DMODULE_NAME="tinybson")
-target_compile_options(tinybson PRIVATE -Wno-sign-compare) # TODO: fix this
+target_compile_options(tinybson PRIVATE -Wno-sign-compare -Wno-error) # TODO: fix this
 add_dependencies(tinybson prebuild_targets)

src/lib/parameters/tinybson/tinybson.cpp

@@ -45,7 +45,7 @@
 
 #include "tinybson.h"
 
-#if 0
+#if 1
 # define debug(fmt, args...)		do { PX4_INFO("BSON: " fmt, ##args); } while(0)
 #else
 # define debug(fmt, args...)		do { } while(0)
@@ -64,7 +64,14 @@ read_x(bson_decoder_t decoder, void *p, size_t s)
 	CODER_CHECK(decoder);
 
 	if (decoder->fd > -1) {
-		return (BSON_READ(decoder->fd, p, s) == s) ? 0 : -1;
+		int ret = BSON_READ(decoder->fd, p, s);
+
+		if (ret == s) {
+			decoder->total_bytes_imported += ret;
+			return 0;
+		}
+
+		return -1;
 	}
 
 	if (decoder->buf != nullptr) {
@@ -79,6 +86,7 @@ read_x(bson_decoder_t decoder, void *p, size_t s)
 
 		memcpy(p, (decoder->buf + decoder->bufpos), s);
 		decoder->bufpos += s;
+		decoder->total_bytes_imported += s;
 		return 0;
 	}
 
@@ -113,8 +121,6 @@ read_double(bson_decoder_t decoder, double *d)
 int
 bson_decoder_init_file(bson_decoder_t decoder, int fd, bson_decoder_callback callback, void *priv)
 {
-	int32_t	junk;
-
 	decoder->fd = fd;
 	decoder->buf = nullptr;
 	decoder->dead = false;
@@ -125,10 +131,14 @@ bson_decoder_init_file(bson_decoder_t decoder, int fd, bson_decoder_callback cal
 	decoder->node.type = BSON_UNDEFINED;
 
 	/* read and discard document size */
-	if (read_int32(decoder, &junk)) {
+	int32_t	junk_size = 0;
+
+	if (read_int32(decoder, &junk_size)) {
 		CODER_KILL(decoder, "failed discarding length");
 	}
 
+	debug("junk_size = %d", junk_size);
+
 	/* ready for decoding */
 	return 0;
 }
@@ -340,7 +350,14 @@ write_x(bson_encoder_t encoder, const void *p, size_t s)
 
 	/* bson file encoder (non-buffered) */
 	if (encoder->fd > -1 && encoder->buf == nullptr) {
-		return (BSON_WRITE(encoder->fd, p, s) == (int)s) ? 0 : -1;
+		int ret = BSON_WRITE(encoder->fd, p, s);
+
+		if (ret == s) {
+			encoder->total_written_size += ret;
+			return 0;
+		}
+
+		return -1;
 	}
 
 	/* do we need to extend the buffer? */
@@ -353,6 +370,8 @@ write_x(bson_encoder_t encoder, const void *p, size_t s)
 			int ret = BSON_WRITE(encoder->fd, encoder->buf, encoder->bufpos);
 
 			if (ret == (int)encoder->bufpos) {
+				encoder->total_written_size += ret;
+
 				// reset buffer to beginning and continue
 				encoder->bufpos = 0;
 
@@ -432,6 +451,8 @@ bson_encoder_init_file(bson_encoder_t encoder, int fd)
 	encoder->buf = nullptr;
 	encoder->dead = false;
 
+	encoder->total_written_size = 0;
+
 	if (write_int32(encoder, 0)) {
 		CODER_KILL(encoder, "write error on document length");
 	}
@@ -449,6 +470,8 @@ bson_encoder_init_buf_file(bson_encoder_t encoder, int fd, void *buf, unsigned b
 	encoder->dead = false;
 	encoder->realloc_ok = false;
 
+	encoder->total_written_size = 0;
+
 	if (write_int32(encoder, 0)) {
 		CODER_KILL(encoder, "write error on document length");
 	}
@@ -473,6 +496,8 @@ bson_encoder_init_buf(bson_encoder_t encoder, void *buf, unsigned bufsize)
 		encoder->realloc_ok = false;
 	}
 
+	encoder->total_written_size = 0;
+
 	if (write_int32(encoder, 0)) {
 		CODER_KILL(encoder, "write error on document length");
 	}
@@ -489,13 +514,30 @@ bson_encoder_fini(bson_encoder_t encoder)
 		CODER_KILL(encoder, "write error on document terminator");
 	}
 
-	if (encoder->fd > -1 && encoder->buf != nullptr) {
-		/* write final buffer to disk */
+	if (encoder->fd > -1 && encoder->bufpos > 0) {
 		int ret = BSON_WRITE(encoder->fd, encoder->buf, encoder->bufpos);
 
-		if (ret != (int)encoder->bufpos) {
+		if (ret == (int)encoder->bufpos) {
+			encoder->total_written_size += ret;
+
+		} else {
 			CODER_KILL(encoder, "write error");
 		}
+	}
+
+	// record document size
+	if (encoder->fd > -1) {
+		off_t offset = lseek(encoder->fd, 0, SEEK_SET);
+
+		int32_t total_document_size = encoder->total_written_size;
+
+		debug("writing document size %d to beginning of file (%d)", total_document_size, offset);
+
+		if (BSON_WRITE(encoder->fd, &total_document_size, sizeof(total_document_size)) != sizeof(total_document_size)) {
+			CODER_KILL(encoder, "write error on document length");
+		}
+
+		BSON_FSYNC(encoder->fd);
 
 	} else if (encoder->buf != nullptr) {
 		/* update buffer length */
@@ -503,11 +545,6 @@ bson_encoder_fini(bson_encoder_t encoder)
 		memcpy(encoder->buf, &len, sizeof(len));
 	}
 
-	/* sync file */
-	if (encoder->fd > -1) {
-		BSON_FSYNC(encoder->fd);
-	}
-
 	return 0;
 }
 
@@ -549,25 +586,17 @@ int bson_encoder_append_bool(bson_encoder_t encoder, const char *name, bool valu
 }
 
 int
-bson_encoder_append_int(bson_encoder_t encoder, const char *name, int64_t value)
+bson_encoder_append_int32(bson_encoder_t encoder, const char *name, int32_t value)
 {
 	bool result;
 
 	CODER_CHECK(encoder);
 
 	/* use the smallest encoding that will hold the value */
-	if (value == (int32_t)value) {
-		debug("encoding %lld as int32", value);
-		result = write_int8(encoder, BSON_INT32) ||
-			 write_name(encoder, name) ||
-			 write_int32(encoder, value);
-
-	} else {
-		debug("encoding %lld as int64", value);
-		result = write_int8(encoder, BSON_INT64) ||
-			 write_name(encoder, name) ||
-			 write_int64(encoder, value);
-	}
+	debug("encoding %lld as int32", value);
+	result = write_int8(encoder, BSON_INT32) ||
+		 write_name(encoder, name) ||
+		 write_int32(encoder, value);
 
 	if (result) {
 		CODER_KILL(encoder, "write error on BSON_INT");

src/lib/parameters/tinybson/tinybson.h

@@ -103,19 +103,22 @@ typedef int	(* bson_decoder_callback)(bson_decoder_t decoder, void *priv, bson_n
 
 struct bson_decoder_s {
 	/* file reader state */
-	int			fd;
+	int			fd{-1};
 
 	/* buffer reader state */
-	uint8_t			*buf;
-	size_t			bufsize;
-	unsigned		bufpos;
+	uint8_t			*buf{nullptr};
+	size_t			bufsize{0};
+	unsigned		bufpos{0};
+	size_t                  total_bytes_imported{0};
 
-	bool			dead;
-	bson_decoder_callback	callback;
-	void			*priv;
-	unsigned		nesting;
+	bool			dead{false};
+	bson_decoder_callback	callback{nullptr};
+	void			*priv{nullptr};
+	unsigned		nesting{0};
 	struct bson_node_s	node;
-	int32_t			pending;
+	int32_t			pending{0};
+
+	uint32_t                import_scratch{0};
 };
 
 /**
@@ -179,6 +182,8 @@ typedef struct bson_encoder_s {
 	unsigned	bufsize;
 	unsigned	bufpos;
 
+	size_t          total_written_size{0};
+
 	bool		realloc_ok;
 	bool		dead;
 
@@ -252,7 +257,7 @@ __EXPORT int bson_encoder_append_bool(bson_encoder_t encoder, const char *name,
  * @param name			Node name.
  * @param value			Value to be encoded.
  */
-__EXPORT int bson_encoder_append_int(bson_encoder_t encoder, const char *name, int64_t value);
+__EXPORT int bson_encoder_append_int32(bson_encoder_t encoder, const char *name, int32_t value);
 
 /**
  * Append a double to the encoded stream

src/lib/systemlib/hardfault_log.h

@@ -41,10 +41,16 @@
 /****************************************************************************
  * Pre-processor Definitions
  ****************************************************************************/
+
+/* The path to the Battery Backed up SRAM */
+#define BBSRAM_PATH "/fs/bbr"
+
 #define HARDFAULT_REBOOT_FILENO 0
 #define HARDFAULT_REBOOT_PATH BBSRAM_PATH "" STRINGIFY(HARDFAULT_REBOOT_FILENO)
+
 #define HARDFAULT_ULOG_FILENO 3
 #define HARDFAULT_ULOG_PATH BBSRAM_PATH "" STRINGIFY(HARDFAULT_ULOG_FILENO)
+
 #define HARDFAULT_FILENO 4
 #define HARDFAULT_PATH BBSRAM_PATH "" STRINGIFY(HARDFAULT_FILENO)
 
@@ -63,20 +69,18 @@
  */
 #define BBSRAM_HEADER_SIZE 20 /* This is an assumption */
 #define BBSRAM_USED ((5*BBSRAM_HEADER_SIZE)+(BBSRAM_SIZE_FN0+BBSRAM_SIZE_FN1+BBSRAM_SIZE_FN2+BBSRAM_SIZE_FN3))
-#define BBSRAM_REAMINING (PX4_BBSRAM_SIZE-BBSRAM_USED)
+#define BBSRAM_REMAINING (PX4_BBSRAM_SIZE-BBSRAM_USED)
 #if CONFIG_ARCH_INTERRUPTSTACK <= 3
 #  define BBSRAM_NUMBER_STACKS 1
 #else
 #  define BBSRAM_NUMBER_STACKS 2
 #endif
 #define BBSRAM_FIXED_ELEMENTS_SIZE (sizeof(info_s))
-#define BBSRAM_LEFTOVER (BBSRAM_REAMINING-BBSRAM_FIXED_ELEMENTS_SIZE)
+#define BBSRAM_LEFTOVER (BBSRAM_REMAINING-BBSRAM_FIXED_ELEMENTS_SIZE)
 
 #define CONFIG_ISTACK_SIZE (BBSRAM_LEFTOVER/BBSRAM_NUMBER_STACKS/sizeof(stack_word_t))
 #define CONFIG_USTACK_SIZE (BBSRAM_LEFTOVER/BBSRAM_NUMBER_STACKS/sizeof(stack_word_t))
 
-/* The path to the Battery Backed up SRAM */
-#define BBSRAM_PATH "/fs/bbr"
 /* The sizes of the files to create (-1) use rest of BBSRAM memory */
 #define BSRAM_FILE_SIZES { \
 		BBSRAM_SIZE_FN0,   /* For Time stamp only */                  \
@@ -256,15 +260,13 @@ typedef struct {
 	fault_regs_s          fault_regs;             /* NVIC status */
 	stack_t               stacks;                 /* Stack info */
 #if CONFIG_TASK_NAME_SIZE > 0
-	char                  name[CONFIG_TASK_NAME_SIZE + 1]; /* Task name (with NULL
-													* terminator) */
+	char                  name[CONFIG_TASK_NAME_SIZE + 1]; /* Task name (with NULL terminator) */
 #endif
-	char                  filename[MAX_FILE_PATH_LENGTH]; /* the Last of chars in
-												  * __FILE__ to up_assert */
+	char                  filename[MAX_FILE_PATH_LENGTH]; /* the Last of chars in __FILE__ to up_assert */
 } info_s;
 
 typedef struct {
-	info_s    info;                       /* The info */
+	info_s    info;                 /* The info */
 #if CONFIG_ARCH_INTERRUPTSTACK > 3      /* The amount of stack data is compile time
 									 * sized backed on what is left after the
 									 * other BBSRAM files are defined

src/modules/mavlink/mavlink_receiver.cpp

@@ -2232,6 +2232,12 @@ MavlinkReceiver::handle_message_hil_gps(mavlink_message_t *msg)
 
 	sensor_gps_s gps{};
 
+	device::Device::DeviceId device_id{};
+	device_id.devid_s.bus_type = device::Device::DeviceBusType::DeviceBusType_MAVLINK;
+	device_id.devid_s.address = msg->sysid;
+	device_id.devid_s.devtype = DRV_GPS_DEVTYPE_SIM;
+	gps.device_id = device_id.devid;
+
 	gps.lat = hil_gps.lat;
 	gps.lon = hil_gps.lon;
 	gps.alt = hil_gps.alt;

src/modules/sih/sih.cpp

@@ -46,6 +46,7 @@
 #include <px4_platform_common/log.h>
 
 #include <drivers/drv_pwm_output.h>         // to get PWM flags
+#include <lib/drivers/device/Device.hpp>
 
 using namespace math;
 using namespace matrix;
@@ -364,6 +365,14 @@ void Sih::send_gps()
 		gps_no_fix();
 	}
 
+	// device id
+	device::Device::DeviceId device_id;
+	device_id.devid_s.bus_type = device::Device::DeviceBusType::DeviceBusType_SIMULATION;
+	device_id.devid_s.bus = 0;
+	device_id.devid_s.address = 0;
+	device_id.devid_s.devtype = DRV_GPS_DEVTYPE_SIM;
+	_sensor_gps.device_id = device_id.devid;
+
 	_sensor_gps_pub.publish(_sensor_gps);
 }
 

src/modules/simulator/simulator_mavlink.cpp

@@ -44,6 +44,7 @@
 #include <drivers/drv_pwm_output.h>
 #include <conversion/rotation.h>
 #include <mathlib/mathlib.h>
+#include <lib/drivers/device/Device.hpp>
 
 #include <arpa/inet.h>
 #include <errno.h>
@@ -432,6 +433,14 @@ void Simulator::handle_message_hil_gps(const mavlink_message_t *msg)
 			if (_sensor_gps_pubs[i] == nullptr) {
 				_sensor_gps_pubs[i] = new uORB::PublicationMulti<sensor_gps_s> {ORB_ID(sensor_gps)};
 				_gps_ids[i] = hil_gps.id;
+
+				device::Device::DeviceId device_id;
+				device_id.devid_s.bus_type = device::Device::DeviceBusType::DeviceBusType_SIMULATION;
+				device_id.devid_s.bus = 0;
+				device_id.devid_s.address = i;
+				device_id.devid_s.devtype = DRV_GPS_DEVTYPE_SIM;
+				gps.device_id = device_id.devid;
+
 				_sensor_gps_pubs[i]->publish(gps);
 				break;
 			}

src/systemcmds/hardfault_log/hardfault_log.c

@@ -61,39 +61,8 @@
 
 #include "chip.h"
 
-
-/****************************************************************************
- * Public Function Prototypes
- ****************************************************************************/
-__EXPORT int hardfault_log_main(int argc, char *argv[]);
-
-/****************************************************************************
- * Pre-processor Definitions
- ****************************************************************************/
 #define OUT_BUFFER_LEN  200
 
-/****************************************************************************
- * Private Types
- ****************************************************************************/
-
-/****************************************************************************
- * Private Function Prototypes
- ****************************************************************************/
-static int genfault(int fault);
-/****************************************************************************
- * Private Data
- ****************************************************************************/
-/****************************************************************************
- * Public Data
- ****************************************************************************/
-
-/****************************************************************************
- * Private Functions
- ****************************************************************************/
-/****************************************************************************
- * genfault
- ****************************************************************************/
-
 static int genfault(int fault)
 {
 
@@ -140,7 +109,7 @@ bool verify_ram_address(uint32_t bot, uint32_t size)
 {
 	bool ret = true;
 #if defined STM32_IS_SRAM
-	ret =  STM32_IS_SRAM(bot) && STM32_IS_SRAM(bot +  size);
+	ret = STM32_IS_SRAM(bot) && STM32_IS_SRAM(bot + size);
 #endif
 	return ret;
 }
@@ -213,7 +182,6 @@ static void identify(const char *caller)
 	}
 }
 
-
 /****************************************************************************
  * hardfault_get_desc
  ****************************************************************************/
@@ -469,8 +437,7 @@ static int write_registers_info(int fdout, info_s *pi, char *buffer, int sz)
 /****************************************************************************
  * write_interrupt_stack_info
  ****************************************************************************/
-static int write_interrupt_stack_info(int fdout, info_s *pi, char *buffer,
-				      unsigned int sz)
+static int write_interrupt_stack_info(int fdout, info_s *pi, char *buffer, unsigned int sz)
 {
 	int ret = ENOENT;
 
@@ -502,8 +469,7 @@ static int write_user_stack_info(int fdout, info_s *pi, char *buffer,
 /****************************************************************************
  * write_dump_info
  ****************************************************************************/
-static int write_dump_info(int fdout, info_s *info, struct bbsramd_s *desc,
-			   char *buffer, unsigned int sz)
+static int write_dump_info(int fdout, info_s *info, struct bbsramd_s *desc, char *buffer, unsigned int sz)
 {
 	char fmtbuff[ TIME_FMT_LEN + 1];
 	format_fault_time(HEADER_TIME_FMT, &desc->lastwrite, fmtbuff, sizeof(fmtbuff));
@@ -528,11 +494,9 @@ static int write_dump_info(int fdout, info_s *info, struct bbsramd_s *desc,
 	}
 
 #ifdef CONFIG_TASK_NAME_SIZE
-	n = snprintf(buffer, sz, " in file:%s at line: %d running task: %s\n",
-		     info->filename, info->lineno, info->name);
+	n = snprintf(buffer, sz, " in file:%s at line: %d running task: %s\n", info->filename, info->lineno, info->name);
 #else
-	n = snprintf(buffer, sz, " in file:%s at line: %d \n",
-		     info->filename, info->lineno);
+	n = snprintf(buffer, sz, " in file:%s at line: %d \n", info->filename, info->lineno);
 #endif
 
 	if (n != write(fdout, buffer, n)) {
@@ -563,8 +527,7 @@ static int write_dump_info(int fdout, info_s *info, struct bbsramd_s *desc,
 /****************************************************************************
  * write_dump_time
  ****************************************************************************/
-static int write_dump_time(char *caller, char *tag, int fdout,
-			   struct timespec *ts, char *buffer, unsigned int sz)
+static int write_dump_time(char *caller, char *tag, int fdout, struct timespec *ts, char *buffer, unsigned int sz)
 {
 	int ret = OK;
 	char fmtbuff[ TIME_FMT_LEN + 1];
@@ -577,27 +540,27 @@ static int write_dump_time(char *caller, char *tag, int fdout,
 
 	return ret;
 }
+
 /****************************************************************************
  * write_dump_footer
  ****************************************************************************/
-static int write_dump_header(char *caller, int fdout, struct timespec *ts,
-			     char *buffer, unsigned int sz)
+static int write_dump_header(char *caller, int fdout, struct timespec *ts, char *buffer, unsigned int sz)
 {
 	return write_dump_time(caller, "Begin", fdout, ts, buffer, sz);
 }
+
 /****************************************************************************
  * write_dump_footer
  ****************************************************************************/
-static int write_dump_footer(char *caller, int fdout, struct timespec *ts,
-			     char *buffer, unsigned int sz)
+static int write_dump_footer(char *caller, int fdout, struct timespec *ts, char *buffer, unsigned int sz)
 {
 	return write_dump_time(caller, "END", fdout, ts, buffer, sz);
 }
+
 /****************************************************************************
  * write_intterupt_satck
  ****************************************************************************/
-static int write_intterupt_stack(int fdin, int fdout, info_s *pi, char *buffer,
-				 unsigned int sz)
+static int write_intterupt_stack(int fdin, int fdout, info_s *pi, char *buffer, unsigned int sz)
 {
 	int ret = ENOENT;
 
@@ -615,12 +578,10 @@ static int write_intterupt_stack(int fdin, int fdout, info_s *pi, char *buffer,
 	return ret;
 }
 
-
 /****************************************************************************
  * write_user_stack
  ****************************************************************************/
-static int write_user_stack(int fdin, int fdout, info_s *pi, char *buffer,
-			    unsigned int sz)
+static int write_user_stack(int fdin, int fdout, info_s *pi, char *buffer, unsigned int sz)
 {
 	int ret = ENOENT;
 
@@ -646,7 +607,6 @@ static int write_user_stack(int fdin, int fdout, info_s *pi, char *buffer,
  */
 static int hardfault_append_to_ulog(const char *caller, int fdin)
 {
-
 	int ret = 0;
 	int write_size_remaining = lseek(fdin, 0, SEEK_END);
 
@@ -769,7 +729,6 @@ static int hardfault_append_to_ulog(const char *caller, int fdin)
 		goto out;
 	}
 
-
 	// now append the data
 	lseek(ulog_fd, 0, SEEK_END);
 
@@ -835,7 +794,6 @@ out:
 	return ret;
 }
 
-
 /****************************************************************************
  * commit
  ****************************************************************************/
@@ -848,7 +806,6 @@ static int hardfault_commit(char *caller)
 	ret = hardfault_get_desc(caller, &desc, false);
 
 	if (ret >= 0) {
-
 		int fd = ret;
 		state = (desc.lastwrite.tv_sec || desc.lastwrite.tv_nsec) ?  OK : 1;
 		int rv = close(fd);
@@ -858,7 +815,6 @@ static int hardfault_commit(char *caller)
 			syslog(LOG_INFO, "Failed to Close Fault Log (%d)\n", rv);
 
 		} else {
-
 			if (state != OK) {
 				identify(caller);
 				syslog(LOG_INFO, "Nothing to save\n", path);
@@ -910,12 +866,10 @@ static int hardfault_commit(char *caller)
 	return ret;
 }
 
-
 /****************************************************************************
  * hardfault_dowrite
  ****************************************************************************/
-static int hardfault_dowrite(char *caller, int infd, int outfd,
-			     struct bbsramd_s *desc, int format)
+static int hardfault_dowrite(char *caller, int infd, int outfd, struct bbsramd_s *desc, int format)
 {
 	int ret = -ENOMEM;
 	char *line = zalloc(OUT_BUFFER_LEN);
@@ -1009,10 +963,6 @@ static int hardfault_dowrite(char *caller, int infd, int outfd,
 	return ret;
 }
 
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
 /****************************************************************************
  * hardfault_rearm
  ****************************************************************************/
@@ -1101,7 +1051,6 @@ __EXPORT int hardfault_increment_reboot(char *caller, bool reset)
 		syslog(LOG_INFO, "Failed to open Fault reboot count file [%s] (%d)\n", HARDFAULT_REBOOT_PATH, ret);
 
 	} else {
-
 		ret = OK;
 
 		if (!reset) {
@@ -1133,10 +1082,10 @@ __EXPORT int hardfault_increment_reboot(char *caller, bool reset)
 
 	return ret;
 }
+
 /****************************************************************************
  * hardfault_write
  ****************************************************************************/
-
 __EXPORT int hardfault_write(char *caller, int fd, int format, bool rearm)
 {
 	struct bbsramd_s desc;
@@ -1224,15 +1173,12 @@ __EXPORT int hardfault_log_main(int argc, char *argv[])
 	}
 
 	if (!strcmp(argv[1], "check")) {
-
 		return hardfault_check_status(self);
 
 	} else if (!strcmp(argv[1], "rearm")) {
-
 		return hardfault_rearm(self);
 
 	} else if (!strcmp(argv[1], "fault")) {
-
 		int fault = 0;
 
 		if (argc > 2) {
@@ -1242,17 +1188,13 @@ __EXPORT int hardfault_log_main(int argc, char *argv[])
 		return genfault(fault);
 
 	} else if (!strcmp(argv[1], "commit")) {
-
 		return hardfault_commit(self);
 
 	} else if (!strcmp(argv[1], "count")) {
-
 		return hardfault_increment_reboot(self, false);
 
 	} else if (!strcmp(argv[1], "reset")) {
-
 		return hardfault_increment_reboot(self, true);
-
 	}
 
 	print_usage();

src/systemcmds/tests/test_bson.cpp

@@ -66,15 +66,15 @@ encode(bson_encoder_t encoder)
 		return 1;
 	}
 
-	if (bson_encoder_append_int(encoder, "int1", sample_small_int) != 0) {
+	if (bson_encoder_append_int32(encoder, "int1", sample_small_int) != 0) {
 		PX4_ERR("FAIL: encoder: append int failed");
 		return 1;
 	}
 
-	if (bson_encoder_append_int(encoder, "int2", sample_big_int) != 0) {
-		PX4_ERR("FAIL: encoder: append int failed");
-		return 1;
-	}
+	// if (bson_encoder_append_int64(encoder, "int2", sample_big_int) != 0) {
+	// 	PX4_ERR("FAIL: encoder: append int failed");
+	// 	return 1;
+	// }
 
 	if (bson_encoder_append_double(encoder, "double1", sample_double) != 0) {
 		PX4_ERR("FAIL: encoder: append double failed");