Crash to hard fault handler after sending data to queue that is blocked on

[makas005]

Of course!
Everything is wrapped in C++ classes, but I will try to explain.

This is the method that sends the data to the queue. Even though pointers to stack variables are send, this should be alright because it is ensured that the stack scope is not left while the data is read, and the reading task does not write to the memory location.
display_controller_queue_.Send() sends data to the queue (code is below).
WaitForTouchRelease() blocks this task until a touch event is recognised, letting other tasks execut at this point.

TouchController::Error TouchController::Calibrate() {
	TouchCalibrationContainer send_start_calibration_container;
	TouchCalibrationContainer send_1print_calibration_point_container;
	TouchCalibrationContainer send_2print_calibration_point_container;
	TouchPosition pressed_position;

	initialization_sequence_running_ = true;

	send_start_calibration_container.command_ = TouchCalibrationContainer::Command::kStartCalibration;
	display_controller_queue_.Send(&send_start_calibration_container, 10);
	send_1print_calibration_point_container.marker_x = first_calibration_marker_x_;
	send_1print_calibration_point_container.marker_y = first_calibration_marker_y_;
	send_1print_calibration_point_container.command_ = TouchCalibrationContainer::Command::kPrintCalibrationPoint;
	display_controller_queue_.Send(&send_1print_calibration_point_container, 10);


	pressed_position = WaitForTouchRelease();
	touch_driver_.SetCalibrationXOffset(first_calibration_marker_x_-pressed_position.x);
	touch_driver_.SetCalibrationYOffset(first_calibration_marker_y_-pressed_position.y);

	send_2print_calibration_point_container.marker_x = second_calibration_marker_x_;
	send_2print_calibration_point_container.marker_y = second_calibration_marker_y_;
	send_2print_calibration_point_container.command_ = TouchCalibrationContainer::Command::kPrintCalibrationPoint;
	display_controller_queue_.Send(&send_2print_calibration_point_container, 10);

	pressed_position = WaitForTouchRelease();

	return Error::kOk;
}

This is the display_controller_queue_.Send() method that writes to the queue:

IQueue::Error FreeRTOSQueue::Send(IContainer *container,
		std::uint32_t timeout) {

	if (!is_created_)
		return Error::kNotCreated;
	else {
		BaseType_t error_code;
		error_code = xQueueSendToBack(queue_handle_, &container,
				timeout/portTICK_PERIOD_MS);
		if (error_code == pdTRUE)
			return (Error::kOk);
		else if (error_code == errQUEUE_FULL)
			return (Error::kTimeout);
		else
			return (Error::kSendError);
	}
}

The task reading from the queue uses a display_controller_queue_.Receive(fetched_container, 0x0fffffffUL) (fetched container is the read buffer) method that is this:

IQueue::Error FreeRTOSQueue::Receive(IContainer *&container,
		std::uint32_t timeout) {

	if (!is_created_)
		return Error::kNotCreated;
	else {
		BaseType_t error_code;
		error_code = xQueueReceive(queue_handle_, &container,
				timeout / portTICK_PERIOD_MS);
		if (error_code == pdTRUE)
			return (Error::kOk);
		else
			return (Error::kReceiveError);
		return (Error::kOk);
	}
}

All this has definitely worked before…