[스마트 굴비] nRF Connect SDK Matter 조명 구현

varofla@varoflas-MacBook-Pro light_bulb % tree src -L 1 
src
├── app_task.cpp
├── app_task.h
├── aws_iot_integration
├── chip_project_config.h
├── default_zap
├── main.cpp
└── zcl_callbacks.cpp

CHIP_ERROR AppTask::Init() {
  /* Initialize Matter stack */
  ReturnErrorOnFailure(
      Nrf::Matter::PrepareServer(
          Nrf::Matter::InitData{
              .mPostServerInitClbk = []() {
                app::SetAttributePersistenceProvider(&gDeferredAttributePersister);
                gSimpleAttributePersistence.Init(Nrf::Matter::GetPersistentStorageDelegate());
                return CHIP_NO_ERROR;
              }}));

  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));

  ReturnErrorOnFailure(sIdentifyCluster.Init());

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

void AppTask::UpdateClusterState() {
  SystemLayer().ScheduleLambda([this] {
    /* write the new on/off value */
    Protocols::InteractionModel::Status status =
        Clusters::OnOff::Attributes::OnOff::Set(kLightEndpointId, mPWMDevice.IsTurnedOn());
    if (status != Protocols::InteractionModel::Status::Success) {
      LOG_ERR("Updating on/off cluster failed: %x", to_underlying(status));
    }

    /* write the current level */
    status = Clusters::LevelControl::Attributes::CurrentLevel::Set(kLightEndpointId, mPWMDevice.GetLevel());

    if (status != Protocols::InteractionModel::Status::Success) {
      LOG_ERR("Updating level cluster failed: %x", to_underlying(status));
    }
  });
}

void MatterPostAttributeChangeCallback(const chip::app::ConcreteAttributePath &attributePath, uint8_t type,
                                       uint16_t size, uint8_t *value) {
  ClusterId clusterId = attributePath.mClusterId;
  AttributeId attributeId = attributePath.mAttributeId;

  if (clusterId == OnOff::Id && attributeId == OnOff::Attributes::OnOff::Id) {
    ChipLogProgress(Zcl, "Cluster OnOff: attribute OnOff set to %" PRIu8 "", *value);

    AppTask::Instance().GetPWMDevice().InitiateAction(*value ? Nrf::PWMDevice::ON_ACTION : Nrf::PWMDevice::OFF_ACTION,
                                                      static_cast<int32_t>(LightingActor::Remote), value);

  } else if (clusterId == LevelControl::Id && attributeId == LevelControl::Attributes::CurrentLevel::Id) {
    ChipLogProgress(Zcl, "Cluster LevelControl: attribute CurrentLevel set to %" PRIu8 "", *value);
    if (AppTask::Instance().GetPWMDevice().IsTurnedOn()) {
      AppTask::Instance().GetPWMDevice().InitiateAction(
          Nrf::PWMDevice::LEVEL_ACTION, static_cast<int32_t>(LightingActor::Remote), value);
    } else {
      ChipLogDetail(Zcl, "LED is off. Try to use move-to-level-with-on-off instead of move-to-level");
    }
  }
}

void emberAfOnOffClusterInitCallback(EndpointId endpoint) {
  Protocols::InteractionModel::Status status;
  bool storedValue;

  /* Read storedValue on/off value */
  status = Attributes::OnOff::Get(endpoint, &storedValue);

  if (status == Protocols::InteractionModel::Status::Success) {
    /* Set actual state to the cluster state that was last persisted */
    AppTask::Instance().InitPWMDDevice();

    AppTask::Instance().GetPWMDevice().InitiateAction(
        storedValue ? Nrf::PWMDevice::ON_ACTION : Nrf::PWMDevice::OFF_ACTION,
        static_cast<int32_t>(LightingActor::Remote), reinterpret_cast<uint8_t *>(&storedValue));
  }

  AppTask::Instance().UpdateClusterState();
}

~ % west zap-gui

~ % west zap-generate

varofla@varoflas-MacBook-Pro template % tree src -L 1
src
├── app
├── bsp
├── mw
└── main.c

#include "app/app.h"
#include "bsp/bsp.h"

int main() {
  bsp_init();

  app_init();

  app_start();
}

varofla@varoflas-MacBook-Pro template % tree src/mw -L 2
src/mw
├── CMakeLists.txt
└── matter
    ├── CMakeLists.txt
    ├── chip_project_config.h
    ├── default_zap
    ├── matter.cpp
    ├── matter.h
    ├── matter_internal.hpp
    ├── matter_spec.h
    └── zcl_callbacks.cpp

// src/mw/matter/matter.h

#ifndef SRC_MW_MATTER_MATTER_C_BRIDGE
#define SRC_MW_MATTER_MATTER_C_BRIDGE

#include <stdbool.h>
#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif

// (typedef 생략)

/* lifecycle */
matter_c_err_t matter_c_init(const matter_init_params_t *params, matter_ctx_t **out_ctx);
matter_c_err_t matter_c_start(matter_ctx_t *ctx);
void matter_c_deinit(matter_ctx_t *ctx);

/* API */
matter_c_err_t matter_c_set_onoff(matter_ctx_t *ctx, uint16_t endpoint, bool on);
matter_c_err_t matter_c_set_level(matter_ctx_t *ctx, uint16_t endpoint, uint8_t level);
matter_c_err_t matter_c_set_color(matter_ctx_t *ctx, uint16_t endpoint, uint16_t color);

/* Attribute 콜백 등록/해제 */
matter_c_err_t matter_c_register_event_cb(matter_ctx_t *ctx, matter_event_cb_t cb, void *user);
matter_c_err_t matter_c_unregister_event_cb(matter_ctx_t *ctx);

#ifdef __cplusplus
}
#endif

#endif /* SRC_MW_MATTER_MATTER_C_BRIDGE */

// src/mw/matter/zcl_callbacks.cpp

void MatterPostAttributeChangeCallback(const chip::app::ConcreteAttributePath &path,
                                       uint8_t type, uint16_t size, uint8_t *value) {
  (void)type;

  matter_event_t evt{};
  evt.type = MATTER_EVT_ATTRIBUTE_CHANGED;
  evt.endpoint = path.mEndpointId;
  evt.cluster_id = path.mClusterId;
  evt.attribute_id = path.mAttributeId;

  if (value && size <= sizeof(evt.value)) {
    memcpy(evt.value, value, size);
    evt.value_len = size;
  }

  matter_emit_event(evt);
}

// src/mw/matter/matter.cpp

static void emit_event(matter_ctx *ctx, const matter_event_t &evt) {
  if (!ctx || !ctx->cb) {
    return;
  }

  ctx->cb(&evt, ctx->cb_user);
}

void matter_emit_event(const matter_event_t &evt) {
  emit_event(s_ctx, evt);
}

varofla@varoflas-MacBook-Pro template % tree src/bsp -L 2
src/bsp
├── CMakeLists.txt
├── bsp.c
├── bsp.h
├── bulb
│   ├── CMakeLists.txt
│   ├── bulb.c
│   └── bulb.h
└── switchs
    ├── CMakeLists.txt
    ├── switchs.c
    └── switchs.h

/ {
	// (생략)

	pwmleds {

		/delete-node/ pwm_led_1;
		pwm_led_cool: pwm_led_cool {
			pwms = <&pwm20 0 PWM_USEC(1000) PWM_POLARITY_NORMAL>;
		};
		pwm_led_warm: pwm_led_warm {
			pwms = <&pwm20 1 PWM_USEC(1000) PWM_POLARITY_NORMAL>;
		};
	};
};

&pinctrl {
	/delete-node/ pwm20_default;
	/delete-node/ pwm20_sleep;

	/omit-if-no-ref/ pwm20_default: pwm20_default {
		group1 {
			psels = <NRF_PSEL(PWM_OUT0, 1, 10)>,
							<NRF_PSEL(PWM_OUT1, 1, 14)>;
		};
	};

	/omit-if-no-ref/ pwm20_sleep: pwm20_sleep {
		group1 {
			psels = <NRF_PSEL(PWM_OUT0, 1, 10)>,
							<NRF_PSEL(PWM_OUT1, 1, 14)>;
			low-power-enable;
		};
	};
};

// src/bsp/bulb/bulb.h

#ifndef SRC_BSP_BULB_BULB
#define SRC_BSP_BULB_BULB

#include <stdbool.h>
#include <stdint.h>

bool bulb_init(void);

void bulb_set_power(bool value);
void bulb_set_brightness(uint8_t value);
void bulb_set_color_temperature(uint32_t value);

void bulb_update(void);

uint8_t bulb_get_brightness(void);

#endif /* SRC_BSP_BULB_BULB */

varofla@varoflas-MacBook-Pro template % tree src/app -L 2
src/app
├── CMakeLists.txt
├── app.c
├── app.h
├── board_tasks
├── main_task
└── matter_task
    ├── matter_task.c
    └── matter_task.h

// src/app/matter_task/matter_task.c

static void s_task(void *, void *, void *) {
  s_matter_start();

  matter_stack_event_queue_data_t data;
  bool is_provisioned = false; // temp
  for (;;) {
    if (k_msgq_get(&matter_stack_event_queue, &data, K_FOREVER) != 0) {
      continue;
    }

    switch (data.event_data.type) {
    case MATTER_EVT_STACK_READY:
      LOG_DBG("matter stack ready!");
      bulb_task_set_effect(BULB_EFFECT_NONE);
      break;

    // (생략)

    case MATTER_EVT_ATTRIBUTE_CHANGED:
      LOG_DBG("endpoint: %d \t cluster: %d \t attribute: %d",
              (int)data.event_data.endpoint, (int)data.event_data.cluster_id, (int)data.event_data.attribute_id);
      s_update_attribute(&data.event_data);
      break;

    case MATTER_EVT_NONE:
    default:
      break;
    }
  }
}

// src/app/matter_task/matter_task.c

static void s_update_attribute(const matter_event_t *evt) {
  uint16_t endpoint = evt->endpoint;
  uint32_t cluster_id = evt->cluster_id;
  uint32_t attribute_id = evt->attribute_id;
  const uint8_t *data = evt->value;
  uint16_t data_len = evt->value_len;

  switch (cluster_id) {
  case MATTER_CLUSTER_ID_ONOFF:
    s_update_onoff(endpoint, attribute_id, data, data_len);
    break;

  case MATTER_CLUSTER_ID_LEVEL_CONTROL:
    s_update_level(endpoint, attribute_id, data, data_len);
    break;

  case MATTER_CLUSTER_ID_COLOR_CONTROL:
    s_update_color(endpoint, attribute_id, data, data_len);
    break;

  default:
    break;
  }
}