app_task.cpp

/*
 * Copyright (c) 2025 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */

#include "app_task.h"

#include "app/matter_init.h"
#include "app/task_executor.h"
#include "board/board.h"
#include "clusters/identify.h"
#include "lib/core/CHIPError.h"

#include <app/clusters/temperature-measurement-server/CodegenIntegration.h>

#include <zephyr/logging/log.h>

#ifdef CONFIG_BME680
#include <zephyr/drivers/sensor.h>

const device *sBme688SensorDev = DEVICE_DT_GET_ONE(bosch_bme680);
#endif

LOG_MODULE_DECLARE(app, CONFIG_CHIP_APP_LOG_LEVEL);

using namespace ::chip;
using namespace ::chip::app;
using namespace ::chip::DeviceLayer;

namespace
{
constexpr chip::EndpointId kTemperatureSensorEndpointId = 1;

Nrf::Matter::IdentifyCluster sIdentifyCluster(kTemperatureSensorEndpointId);

#ifdef CONFIG_CHIP_ICD_UAT_SUPPORT
#ifdef CONFIG_MATTER_USE_DEFAULT_BUTTON_HANDLER
#define UAT_BUTTON_MASK DK_BTN3_MSK
#endif
#endif

#ifndef CONFIG_MATTER_USE_DEFAULT_BUTTON_HANDLER
constexpr int kSoftwareUpdateTimeout = 1500;
constexpr int kUatTimeout = 1500;
constexpr int kFactoryResetTimeout = 3000;
constexpr int kUatBlinkPeriod = 200;
ButtonState sBtnState = ButtonState::None;
k_timer sBtn1Timer;
#endif

} /* namespace */

void HandleUAT()
{
#ifdef CONFIG_CHIP_ICD_UAT_SUPPORT
	LOG_INF("ICD UserActiveMode has been triggered.");
	Server::GetInstance().GetICDManager().OnNetworkActivity();
#endif
}
/* nRF54T15 TAG has only a single button,
 * therefore the default handler for factory data and software update had to be overridden.
 * On other DK's only UAT is handled by the application.
 */
void AppTask::ButtonEventHandler(Nrf::ButtonState state, Nrf::ButtonMask hasChanged)
{
#ifdef CONFIG_MATTER_USE_DEFAULT_BUTTON_HANDLER
	if (UAT_BUTTON_MASK & state & hasChanged) {
		HandleUAT();
	}
#else
	if (DK_BTN1_MSK & hasChanged) {
		if (DK_BTN1_MSK & state) {
			LOG_INF("Release the button within %ums to trigger Software Update", kSoftwareUpdateTimeout);
			k_timer_start(&sBtn1Timer, K_MSEC(kSoftwareUpdateTimeout), K_NO_WAIT);
			sBtnState = ButtonState::SoftwareUpdate;
		} else {
			if (sBtnState == ButtonState::SoftwareUpdate) {
#ifndef CONFIG_MATTER_CUSTOM_BLUETOOTH_ADVERTISING
				if (Nrf::GetBoard().GetDeviceState() == Nrf::DeviceState::DeviceProvisioned) {
/* In this case we need to run only Bluetooth LE SMP advertising if it is available */
#ifdef CONFIG_CHIP_DFU_OVER_BT_SMP
					GetDFUOverSMP().StartServer();
#else
					LOG_INF("Software update is disabled");
#endif
				} else {
					/* In this case we start both Bluetooth LE SMP and Matter advertising at the
					 * same time */
					Nrf::GetBoard().StartBLEAdvertisement();
				}
#endif
			} else if (sBtnState == ButtonState::UAT) {
				HandleUAT();
			}
			/* Restore LED's state and cancel the timer */
			k_timer_stop(&sBtn1Timer);
			sBtnState = ButtonState::None;
			Nrf::GetBoard().RestoreAllLedsState();
			Nrf::GetBoard().RunLedStateHandler();
		}
	}
#endif
}
#ifndef CONFIG_MATTER_USE_DEFAULT_BUTTON_HANDLER
void ButtonTimerEventHandler()
{
	if (sBtnState == ButtonState::SoftwareUpdate) {
		LOG_INF("Release the button within %ums to trigger UAT", kUatTimeout);
		k_timer_start(&sBtn1Timer, K_MSEC(kUatTimeout), K_NO_WAIT);
		sBtnState = ButtonState::UAT;

		/* Turn off all LEDs before starting blink to make sure blink is coordinated. */
		Nrf::GetBoard().ResetAllLeds();
		Nrf::GetBoard().ForEachLED([](Nrf::LEDWidget &led) { led.Blink(kUatBlinkPeriod); });
	} else if (sBtnState == ButtonState::UAT) {
		LOG_INF("Factory reset has been triggered. Release button within %ums to cancel.",
			kFactoryResetTimeout);

		/* Start timer for sFactoryResetTimeout to allow user to cancel, if required. */
		k_timer_start(&sBtn1Timer, K_MSEC(kFactoryResetTimeout), K_NO_WAIT);
		sBtnState = ButtonState::None;

		Nrf::GetBoard().ForEachLED([](Nrf::LEDWidget &led) { led.Blink(Nrf::LedConsts::kBlinkRate_ms); });
		/* If we reached here, the button was held past FactoryResetTriggerTimeout, initiate factory reset */
	} else if (sBtnState == ButtonState::None) {
		/* Actually trigger Factory Reset */
		chip::Server::GetInstance().ScheduleFactoryReset();
	}
}

void ButtonTimerTimeoutCallback(k_timer *timer)
{
	Nrf::PostTask([] { ButtonTimerEventHandler(); });
}

#endif

void AppTask::UpdateTemperatureMeasurement()
{
#ifdef CONFIG_BME680
	/* Real data from the onboard sensor*/
	int result = sensor_sample_fetch(sBme688SensorDev);
	if (result == 0) {
		sensor_value temperature;
		int result = sensor_channel_get(sBme688SensorDev, SENSOR_CHAN_AMBIENT_TEMP, &temperature);
		if (result == 0) {
			/* Defined by cluster temperature measured value = 100 x temperature in degC with resolution of
			 * 0.01 degC. val1 is an integer part of the value and val2 is fractional part in one-millionth
			 * parts. To achieve resolution of 0.01 degC val2 needs to be divided by 10000. */
			mCurrentTemperature = static_cast<int16_t>(temperature.val1 * 100 + temperature.val2 / 10000);
			LOG_DBG("New temperature measurement %d.%d *C", temperature.val1, temperature.val2);
		} else {
			LOG_ERR("Getting temperature measurement data from BME688 failed with: %d", result);
		}
	} else {
		LOG_ERR("Fetching data from BME688 sensor failed with: %d", result);
	}
#else
	/* Linear temperature increase that is wrapped around to min value after reaching the max value. */
	if (mCurrentTemperature < mTemperatureSensorMaxValue) {
		mCurrentTemperature += kTemperatureMeasurementStep;
	} else {
		mCurrentTemperature = mTemperatureSensorMinValue;
	}
#endif
}

void AppTask::UpdateTemperatureTimeoutCallback(k_timer *timer)
{
	if (!timer || !timer->user_data) {
		return;
	}

	CHIP_ERROR err = DeviceLayer::PlatformMgr().ScheduleWork(
		[](intptr_t p) {
			AppTask::Instance().UpdateTemperatureMeasurement();

			CHIP_ERROR setErr = Clusters::TemperatureMeasurement::SetMeasuredValue(
				kTemperatureSensorEndpointId, AppTask::Instance().GetCurrentTemperature());

			if (setErr != CHIP_NO_ERROR) {
				LOG_ERR("Updating temperature measurement failed %" CHIP_ERROR_FORMAT,
					setErr.Format());
			}
		},
		reinterpret_cast<intptr_t>(timer->user_data));
	if (err != CHIP_NO_ERROR) {
		LOG_ERR("ScheduleWork failed: %" CHIP_ERROR_FORMAT, err.Format());
	}
}

CHIP_ERROR AppTask::Init()
{
	/* Initialize Matter stack */
	ReturnErrorOnFailure(Nrf::Matter::PrepareServer());

	if (!Nrf::GetBoard().Init(ButtonEventHandler)) {
		LOG_ERR("User interface initialization failed.");
		return CHIP_ERROR_INCORRECT_STATE;
	}

	/* Register Matter event handler that controls the connectivity status LED based on the captured Matter network
	 * state. */
	ReturnErrorOnFailure(Nrf::Matter::RegisterEventHandler(Nrf::Board::DefaultMatterEventHandler, 0));
#ifdef CONFIG_BME680
	if (!device_is_ready(sBme688SensorDev)) {
		LOG_ERR("BME688 sensor device not ready");
		return chip::System::MapErrorZephyr(-ENODEV);
	}
#endif

	return Nrf::Matter::StartServer();
}

CHIP_ERROR AppTask::StartApp()
{
	ReturnErrorOnFailure(Init());

	auto *temperatureMeasurement =
		Clusters::TemperatureMeasurement::FindClusterOnEndpoint(kTemperatureSensorEndpointId);

	if (temperatureMeasurement == nullptr) {
		LOG_ERR("Failed to find TemperatureMeasurement cluster");
		return CHIP_ERROR_INCORRECT_STATE;
	}

	DataModel::Nullable<int16_t> minVal = temperatureMeasurement->GetMinMeasuredValue();
	if (minVal.IsNull()) {
		LOG_ERR("Failed to get temperature measurement min value");
		return CHIP_ERROR_INCORRECT_STATE;
	}
	mTemperatureSensorMinValue = minVal.Value();

	DataModel::Nullable<int16_t> maxVal = temperatureMeasurement->GetMaxMeasuredValue();
	if (maxVal.IsNull()) {
		LOG_ERR("Failed to get temperature measurement max value");
		return CHIP_ERROR_INCORRECT_STATE;
	}
	mTemperatureSensorMaxValue = maxVal.Value();

	k_timer_init(&mTimer, AppTask::UpdateTemperatureTimeoutCallback, nullptr);
	k_timer_user_data_set(&mTimer, this);
	k_timer_start(&mTimer, K_MSEC(kTemperatureMeasurementIntervalMs), K_MSEC(kTemperatureMeasurementIntervalMs));
#ifndef CONFIG_MATTER_USE_DEFAULT_BUTTON_HANDLER
	k_timer_init(&sBtn1Timer, &ButtonTimerTimeoutCallback, nullptr);
#endif
	while (true) {
		Nrf::DispatchNextTask();
	}

	return CHIP_NO_ERROR;
}