From 27ec88bb264602012c9315fed0f25431c0fa14a5 Mon Sep 17 00:00:00 2001 From: Hyundo Lee <54927573+hdlee27@users.noreply.github.com> Date: Fri, 13 Mar 2020 10:57:41 +0900 Subject: [PATCH] apps : change app style using capability files Signed-off-by: Hyundo Lee <54927573+hdlee27@users.noreply.github.com> --- .../main/caps_airQualitySensor.c | 112 +++ .../main/caps_airQualitySensor.h | 36 + apps/esp8266/st_air_monitor/main/caps_alarm.c | 169 ++++ apps/esp8266/st_air_monitor/main/caps_alarm.h | 38 + .../main/caps_carbonDioxideMeasurement.c | 112 +++ .../main/caps_carbonDioxideMeasurement.h | 36 + .../main/caps_carbonMonoxideDetector.c | 92 ++ .../main/caps_carbonMonoxideDetector.h | 33 + .../main/caps_formaldehydeMeasurement.c | 112 +++ .../main/caps_formaldehydeMeasurement.h | 36 + .../st_air_monitor/main/smart_air_monitor.c | 427 +++------ apps/esp8266/st_lamp/main/caps_colorControl.c | 198 ++++ apps/esp8266/st_lamp/main/caps_colorControl.h | 42 + apps/esp8266/st_lamp/main/caps_switch.c | 134 +++ apps/esp8266/st_lamp/main/caps_switch.h | 36 + apps/esp8266/st_lamp/main/caps_switchLevel.c | 138 +++ apps/esp8266/st_lamp/main/caps_switchLevel.h | 38 + apps/esp8266/st_lamp/main/device_control.h | 7 + apps/esp8266/st_lamp/main/smart_lamp.c | 371 +++---- apps/esp8266/st_lamp/sdkconfig | 1 - apps/esp8266/st_switch/main/caps_switch.c | 134 +++ apps/esp8266/st_switch/main/caps_switch.h | 36 + apps/esp8266/st_switch/main/device_control.h | 2 - apps/esp8266/st_switch/main/smart_switch.c | 176 ++-- apps/esp8266/st_switch/sdkconfig | 3 - .../main/caps_temperatureMeasurement.c | 112 +++ .../main/caps_temperatureMeasurement.h | 36 + .../main/caps_thermostatCoolingSetpoint.c | 136 +++ .../main/caps_thermostatCoolingSetpoint.h | 38 + .../main/caps_thermostatFanMode.c | 237 +++++ .../main/caps_thermostatFanMode.h | 44 + .../main/caps_thermostatHeatingSetpoint.c | 136 +++ .../main/caps_thermostatHeatingSetpoint.h | 38 + .../st_thermostat/main/caps_thermostatMode.c | 276 ++++++ .../st_thermostat/main/caps_thermostatMode.h | 46 + .../main/caps_thermostatOperatingState.c | 92 ++ .../main/caps_thermostatOperatingState.h | 33 + apps/esp8266/st_thermostat/main/main.c | 902 +++--------------- 38 files changed, 3229 insertions(+), 1416 deletions(-) create mode 100644 apps/esp8266/st_air_monitor/main/caps_airQualitySensor.c create mode 100644 apps/esp8266/st_air_monitor/main/caps_airQualitySensor.h create mode 100644 apps/esp8266/st_air_monitor/main/caps_alarm.c create mode 100644 apps/esp8266/st_air_monitor/main/caps_alarm.h create mode 100644 apps/esp8266/st_air_monitor/main/caps_carbonDioxideMeasurement.c create mode 100644 apps/esp8266/st_air_monitor/main/caps_carbonDioxideMeasurement.h create mode 100644 apps/esp8266/st_air_monitor/main/caps_carbonMonoxideDetector.c create mode 100644 apps/esp8266/st_air_monitor/main/caps_carbonMonoxideDetector.h create mode 100644 apps/esp8266/st_air_monitor/main/caps_formaldehydeMeasurement.c create mode 100644 apps/esp8266/st_air_monitor/main/caps_formaldehydeMeasurement.h create mode 100644 apps/esp8266/st_lamp/main/caps_colorControl.c create mode 100644 apps/esp8266/st_lamp/main/caps_colorControl.h create mode 100644 apps/esp8266/st_lamp/main/caps_switch.c create mode 100644 apps/esp8266/st_lamp/main/caps_switch.h create mode 100644 apps/esp8266/st_lamp/main/caps_switchLevel.c create mode 100644 apps/esp8266/st_lamp/main/caps_switchLevel.h create mode 100644 apps/esp8266/st_switch/main/caps_switch.c create mode 100644 apps/esp8266/st_switch/main/caps_switch.h create mode 100644 apps/esp8266/st_thermostat/main/caps_temperatureMeasurement.c create mode 100644 apps/esp8266/st_thermostat/main/caps_temperatureMeasurement.h create mode 100644 apps/esp8266/st_thermostat/main/caps_thermostatCoolingSetpoint.c create mode 100644 apps/esp8266/st_thermostat/main/caps_thermostatCoolingSetpoint.h create mode 100644 apps/esp8266/st_thermostat/main/caps_thermostatFanMode.c create mode 100644 apps/esp8266/st_thermostat/main/caps_thermostatFanMode.h create mode 100644 apps/esp8266/st_thermostat/main/caps_thermostatHeatingSetpoint.c create mode 100644 apps/esp8266/st_thermostat/main/caps_thermostatHeatingSetpoint.h create mode 100644 apps/esp8266/st_thermostat/main/caps_thermostatMode.c create mode 100644 apps/esp8266/st_thermostat/main/caps_thermostatMode.h create mode 100644 apps/esp8266/st_thermostat/main/caps_thermostatOperatingState.c create mode 100644 apps/esp8266/st_thermostat/main/caps_thermostatOperatingState.h diff --git a/apps/esp8266/st_air_monitor/main/caps_airQualitySensor.c b/apps/esp8266/st_air_monitor/main/caps_airQualitySensor.c new file mode 100644 index 00000000..02f4e754 --- /dev/null +++ b/apps/esp8266/st_air_monitor/main/caps_airQualitySensor.c @@ -0,0 +1,112 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include + +#include "st_dev.h" +#include "caps_airQualitySensor.h" + +#include "freertos/FreeRTOS.h" + +static int caps_airQualitySensor_get_airQuality_value(caps_airQualitySensor_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->airQuality_value; +} + +static void caps_airQualitySensor_set_airQuality_value(caps_airQualitySensor_data_t *caps_data, int value) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->airQuality_value = value; +} + +static const char *caps_airQualitySensor_get_airQuality_unit(caps_airQualitySensor_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->airQuality_unit; +} + +static void caps_airQualitySensor_set_airQuality_unit(caps_airQualitySensor_data_t *caps_data, const char *unit) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->airQuality_unit = (char *)unit; +} + +static void caps_airQualitySensor_attr_airQuality_send(caps_airQualitySensor_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int sequence_no; + + cap_evt = st_cap_attr_create_int((char *) caps_helper_airQualitySensor.attr_airQuality.name, caps_data->airQuality_value, caps_data->airQuality_unit); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send airQuality value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + +static void caps_airQualitySensor_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) +{ + caps_airQualitySensor_data_t *caps_data = usr_data; + if (caps_data && caps_data->init_usr_cb) + caps_data->init_usr_cb(caps_data); + caps_airQualitySensor_attr_airQuality_send(caps_data); +} + +caps_airQualitySensor_data_t *caps_airQualitySensor_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data) +{ + caps_airQualitySensor_data_t *caps_data = NULL; + + caps_data = malloc(sizeof(caps_airQualitySensor_data_t)); + if (!caps_data) { + printf("fail to malloc for caps_airQualitySensor_data\n"); + return NULL; + } + + memset(caps_data, 0, sizeof(caps_airQualitySensor_data_t)); + + caps_data->handle = st_cap_handle_init(ctx, component, caps_helper_airQualitySensor.id , caps_airQualitySensor_init_cb, caps_data); + caps_data->init_usr_cb = init_usr_cb; + caps_data->usr_data = usr_data; + + caps_data->get_airQuality_value = caps_airQualitySensor_get_airQuality_value; + caps_data->set_airQuality_value = caps_airQualitySensor_set_airQuality_value; + caps_data->get_airQuality_unit = caps_airQualitySensor_get_airQuality_unit; + caps_data->set_airQuality_unit = caps_airQualitySensor_set_airQuality_unit; + caps_data->attr_airQuality_send = caps_airQualitySensor_attr_airQuality_send; + + caps_data->airQuality_value = caps_helper_airQualitySensor.attr_airQuality.min; + caps_data->airQuality_unit = (char *)caps_helper_airQualitySensor.attr_airQuality.units[CAPS_HELPER_AIR_QUALITY_SENSOR_UNIT_CAQI]; + + return caps_data; +} diff --git a/apps/esp8266/st_air_monitor/main/caps_airQualitySensor.h b/apps/esp8266/st_air_monitor/main/caps_airQualitySensor.h new file mode 100644 index 00000000..7c00572e --- /dev/null +++ b/apps/esp8266/st_air_monitor/main/caps_airQualitySensor.h @@ -0,0 +1,36 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include "caps/iot_caps_helper_airQualitySensor.h" + +typedef struct caps_airQualitySensor_data { + IOT_CAP_HANDLE* handle; + void *usr_data; + + int airQuality_value; + int (*get_airQuality_value)(struct caps_airQualitySensor_data *caps_data); + void (*set_airQuality_value)(struct caps_airQualitySensor_data *caps_data, int value); + char *airQuality_unit; + const char *(*get_airQuality_unit)(struct caps_airQualitySensor_data *caps_data); + void (*set_airQuality_unit)(struct caps_airQualitySensor_data *caps_data, const char *unit); + void (*attr_airQuality_send)(struct caps_airQualitySensor_data *caps_data); + + void (*init_usr_cb)(struct caps_airQualitySensor_data *caps_data); +} caps_airQualitySensor_data_t; + +caps_airQualitySensor_data_t *caps_airQualitySensor_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data); diff --git a/apps/esp8266/st_air_monitor/main/caps_alarm.c b/apps/esp8266/st_air_monitor/main/caps_alarm.c new file mode 100644 index 00000000..b21d2a15 --- /dev/null +++ b/apps/esp8266/st_air_monitor/main/caps_alarm.c @@ -0,0 +1,169 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include + +#include "st_dev.h" +#include "caps_alarm.h" + +#include "freertos/FreeRTOS.h" + +static const char *caps_alarm_get_alarm_value(caps_alarm_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->alarm_value; +} + +static void caps_alarm_set_alarm_value(caps_alarm_data_t *caps_data, const char *value) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->alarm_value = (char *)value; +} + +static void caps_alarm_attr_alarm_send(caps_alarm_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int sequence_no; + + cap_evt = st_cap_attr_create_string((char *)caps_helper_alarm.attr_alarm.name, + caps_data->alarm_value, NULL); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send alarm value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + +static void caps_alarm_cmd_both_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_alarm_data_t *caps_data = (caps_alarm_data_t *)usr_data; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_alarm_set_alarm_value(caps_data, caps_helper_alarm.attr_alarm.values[CAPS_HELPER_ALARM_VALUE_BOTH]); + if (caps_data && caps_data->cmd_off_usr_cb) + caps_data->cmd_both_usr_cb(caps_data); + caps_alarm_attr_alarm_send(caps_data); +} + +static void caps_alarm_cmd_off_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_alarm_data_t *caps_data = (caps_alarm_data_t *)usr_data; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_alarm_set_alarm_value(caps_data, caps_helper_alarm.attr_alarm.values[CAPS_HELPER_ALARM_VALUE_OFF]); + if (caps_data && caps_data->cmd_off_usr_cb) + caps_data->cmd_off_usr_cb(caps_data); + caps_alarm_attr_alarm_send(caps_data); +} + +static void caps_alarm_cmd_siren_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_alarm_data_t *caps_data = (caps_alarm_data_t *)usr_data; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_alarm_set_alarm_value(caps_data, caps_helper_alarm.attr_alarm.values[CAPS_HELPER_ALARM_VALUE_SIREN]); + if (caps_data && caps_data->cmd_off_usr_cb) + caps_data->cmd_siren_usr_cb(caps_data); + caps_alarm_attr_alarm_send(caps_data); +} + +static void caps_alarm_cmd_strobe_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_alarm_data_t *caps_data = (caps_alarm_data_t *)usr_data; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_alarm_set_alarm_value(caps_data, caps_helper_alarm.attr_alarm.values[CAPS_HELPER_ALARM_VALUE_STROBE]); + if (caps_data && caps_data->cmd_off_usr_cb) + caps_data->cmd_strobe_usr_cb(caps_data); + caps_alarm_attr_alarm_send(caps_data); +} +static void caps_alarm_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) +{ + caps_alarm_data_t *caps_data = usr_data; + if (caps_data && caps_data->init_usr_cb) + caps_data->init_usr_cb(caps_data); + caps_alarm_attr_alarm_send(caps_data); +} + +caps_alarm_data_t *caps_alarm_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data) +{ + caps_alarm_data_t *caps_data = NULL; + int err; + + caps_data = malloc(sizeof(caps_alarm_data_t)); + if (!caps_data) { + printf("fail to malloc for caps_alarm_data\n"); + return NULL; + } + + memset(caps_data, 0, sizeof(caps_alarm_data_t)); + + caps_data->handle = st_cap_handle_init(ctx, component, caps_helper_alarm.id , caps_alarm_init_cb, caps_data); + caps_data->init_usr_cb = init_usr_cb; + caps_data->usr_data = usr_data; + + caps_data->get_alarm_value = caps_alarm_get_alarm_value; + caps_data->set_alarm_value = caps_alarm_set_alarm_value; + caps_data->attr_alarm_send = caps_alarm_attr_alarm_send; + + caps_data->alarm_value = (char *)caps_helper_alarm.attr_alarm.values[CAPS_HELPER_ALARM_VALUE_OFF]; + + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_alarm.cmd_both.name, caps_alarm_cmd_both_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for both\n"); + return NULL; + } + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_alarm.cmd_siren.name, caps_alarm_cmd_siren_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for siren\n"); + return NULL; + } + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_alarm.cmd_off.name, caps_alarm_cmd_off_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for off\n"); + return NULL; + } + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_alarm.cmd_strobe.name, caps_alarm_cmd_strobe_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for strobe\n"); + return NULL; + } + + return caps_data; +} diff --git a/apps/esp8266/st_air_monitor/main/caps_alarm.h b/apps/esp8266/st_air_monitor/main/caps_alarm.h new file mode 100644 index 00000000..84cf5bca --- /dev/null +++ b/apps/esp8266/st_air_monitor/main/caps_alarm.h @@ -0,0 +1,38 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include "caps/iot_caps_helper_alarm.h" + +typedef struct caps_alarm_data { + IOT_CAP_HANDLE* handle; + void *usr_data; + + char *alarm_value; + const char *(*get_alarm_value)(struct caps_alarm_data *caps_data); + void (*set_alarm_value)(struct caps_alarm_data *caps_data, const char* value); + void (*attr_alarm_send)(struct caps_alarm_data *caps_data); + + void (*init_usr_cb)(struct caps_alarm_data *caps_data); + + void (*cmd_both_usr_cb)(struct caps_alarm_data *caps_data); + void (*cmd_off_usr_cb)(struct caps_alarm_data *caps_data); + void (*cmd_siren_usr_cb)(struct caps_alarm_data *caps_data); + void (*cmd_strobe_usr_cb)(struct caps_alarm_data *caps_data); +} caps_alarm_data_t; + +caps_alarm_data_t *caps_alarm_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data); diff --git a/apps/esp8266/st_air_monitor/main/caps_carbonDioxideMeasurement.c b/apps/esp8266/st_air_monitor/main/caps_carbonDioxideMeasurement.c new file mode 100644 index 00000000..ab31c54d --- /dev/null +++ b/apps/esp8266/st_air_monitor/main/caps_carbonDioxideMeasurement.c @@ -0,0 +1,112 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include + +#include "st_dev.h" +#include "caps_carbonDioxideMeasurement.h" + +#include "freertos/FreeRTOS.h" + +static int caps_carbonDioxideMeasurement_get_carbonDioxide_value(caps_carbonDioxideMeasurement_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->carbonDioxide_value; +} + +static void caps_carbonDioxideMeasurement_set_carbonDioxide_value(caps_carbonDioxideMeasurement_data_t *caps_data, int value) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->carbonDioxide_value = value; +} + +static const char *caps_carbonDioxideMeasurement_get_carbonDioxide_unit(caps_carbonDioxideMeasurement_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->carbonDioxide_unit; +} + +static void caps_carbonDioxideMeasurement_set_carbonDioxide_unit(caps_carbonDioxideMeasurement_data_t *caps_data, const char *unit) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->carbonDioxide_unit = (char *)unit; +} + +static void caps_carbonDioxideMeasurement_attr_carbonDioxide_send(caps_carbonDioxideMeasurement_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int sequence_no; + + cap_evt = st_cap_attr_create_int((char *) caps_helper_carbonDioxideMeasurement.attr_carbonDioxide.name, caps_data->carbonDioxide_value, caps_data->carbonDioxide_unit); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send carbonDioxide value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + +static void caps_carbonDioxideMeasurement_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) +{ + caps_carbonDioxideMeasurement_data_t *caps_data = usr_data; + if (caps_data && caps_data->init_usr_cb) + caps_data->init_usr_cb(caps_data); + caps_carbonDioxideMeasurement_attr_carbonDioxide_send(caps_data); +} + +caps_carbonDioxideMeasurement_data_t *caps_carbonDioxideMeasurement_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data) +{ + caps_carbonDioxideMeasurement_data_t *caps_data = NULL; + + caps_data = malloc(sizeof(caps_carbonDioxideMeasurement_data_t)); + if (!caps_data) { + printf("fail to malloc for caps_carbonDioxideMeasurement_data\n"); + return NULL; + } + + memset(caps_data, 0, sizeof(caps_carbonDioxideMeasurement_data_t)); + + caps_data->handle = st_cap_handle_init(ctx, component, caps_helper_carbonDioxideMeasurement.id , caps_carbonDioxideMeasurement_init_cb, caps_data); + caps_data->init_usr_cb = init_usr_cb; + caps_data->usr_data = usr_data; + + caps_data->get_carbonDioxide_value = caps_carbonDioxideMeasurement_get_carbonDioxide_value; + caps_data->set_carbonDioxide_value = caps_carbonDioxideMeasurement_set_carbonDioxide_value; + caps_data->get_carbonDioxide_unit = caps_carbonDioxideMeasurement_get_carbonDioxide_unit; + caps_data->set_carbonDioxide_unit = caps_carbonDioxideMeasurement_set_carbonDioxide_unit; + caps_data->attr_carbonDioxide_send = caps_carbonDioxideMeasurement_attr_carbonDioxide_send; + + caps_data->carbonDioxide_value = caps_helper_carbonDioxideMeasurement.attr_carbonDioxide.min; + caps_data->carbonDioxide_unit = (char *)caps_helper_carbonDioxideMeasurement.attr_carbonDioxide.units[CAPS_HELPER_CARBON_DIOXIDE_MEASUREMENT_UNIT_PPM]; + + return caps_data; +} diff --git a/apps/esp8266/st_air_monitor/main/caps_carbonDioxideMeasurement.h b/apps/esp8266/st_air_monitor/main/caps_carbonDioxideMeasurement.h new file mode 100644 index 00000000..566e7915 --- /dev/null +++ b/apps/esp8266/st_air_monitor/main/caps_carbonDioxideMeasurement.h @@ -0,0 +1,36 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include "caps/iot_caps_helper_carbonDioxideMeasurement.h" + +typedef struct caps_carbonDioxideMeasurement_data { + IOT_CAP_HANDLE* handle; + void *usr_data; + + int carbonDioxide_value; + int (*get_carbonDioxide_value)(struct caps_carbonDioxideMeasurement_data *caps_data); + void (*set_carbonDioxide_value)(struct caps_carbonDioxideMeasurement_data *caps_data, int value); + char *carbonDioxide_unit; + const char *(*get_carbonDioxide_unit)(struct caps_carbonDioxideMeasurement_data *caps_data); + void (*set_carbonDioxide_unit)(struct caps_carbonDioxideMeasurement_data *caps_data, const char *unit); + void (*attr_carbonDioxide_send)(struct caps_carbonDioxideMeasurement_data *caps_data); + + void (*init_usr_cb)(struct caps_carbonDioxideMeasurement_data *caps_data); +} caps_carbonDioxideMeasurement_data_t; + +caps_carbonDioxideMeasurement_data_t *caps_carbonDioxideMeasurement_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data); diff --git a/apps/esp8266/st_air_monitor/main/caps_carbonMonoxideDetector.c b/apps/esp8266/st_air_monitor/main/caps_carbonMonoxideDetector.c new file mode 100644 index 00000000..023fc6ce --- /dev/null +++ b/apps/esp8266/st_air_monitor/main/caps_carbonMonoxideDetector.c @@ -0,0 +1,92 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include + +#include "st_dev.h" +#include "caps_carbonMonoxideDetector.h" + +#include "freertos/FreeRTOS.h" + +static const char *caps_carbonMonoxideDetector_get_carbonMonoxide_value(caps_carbonMonoxideDetector_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->carbonMonoxide_value; +} + +static void caps_carbonMonoxideDetector_set_carbonMonoxide_value(caps_carbonMonoxideDetector_data_t *caps_data, const char *value) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->carbonMonoxide_value = (char *)value; +} + +static void caps_carbonMonoxideDetector_attr_carbonMonoxide_send(caps_carbonMonoxideDetector_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int sequence_no; + + cap_evt = st_cap_attr_create_string((char *)caps_helper_carbonMonoxideDetector.attr_carbonMonoxide.name, + caps_data->carbonMonoxide_value, NULL); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send carbonMonoxide value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + +static void caps_carbonMonoxideDetector_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) +{ + caps_carbonMonoxideDetector_data_t *caps_data = usr_data; + if (caps_data && caps_data->init_usr_cb) + caps_data->init_usr_cb(caps_data); + caps_carbonMonoxideDetector_attr_carbonMonoxide_send(caps_data); +} + +caps_carbonMonoxideDetector_data_t *caps_carbonMonoxideDetector_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data) +{ + caps_carbonMonoxideDetector_data_t *caps_data = NULL; + + caps_data = malloc(sizeof(caps_carbonMonoxideDetector_data_t)); + if (!caps_data) { + printf("fail to malloc for caps_carbonMonoxideDetector_data\n"); + return NULL; + } + + memset(caps_data, 0, sizeof(caps_carbonMonoxideDetector_data_t)); + + caps_data->handle = st_cap_handle_init(ctx, component, caps_helper_carbonMonoxideDetector.id , caps_carbonMonoxideDetector_init_cb, caps_data); + caps_data->init_usr_cb = init_usr_cb; + caps_data->usr_data = usr_data; + + caps_data->get_carbonMonoxide_value = caps_carbonMonoxideDetector_get_carbonMonoxide_value; + caps_data->set_carbonMonoxide_value = caps_carbonMonoxideDetector_set_carbonMonoxide_value; + caps_data->attr_carbonMonoxide_send = caps_carbonMonoxideDetector_attr_carbonMonoxide_send; + + caps_data->carbonMonoxide_value = (char *)caps_helper_carbonMonoxideDetector.attr_carbonMonoxide.values[CAPS_HELPER_CARBON_MONOXIDE_DETECTOR_VALUE_CLEAR]; + + return caps_data; +} diff --git a/apps/esp8266/st_air_monitor/main/caps_carbonMonoxideDetector.h b/apps/esp8266/st_air_monitor/main/caps_carbonMonoxideDetector.h new file mode 100644 index 00000000..443e00d9 --- /dev/null +++ b/apps/esp8266/st_air_monitor/main/caps_carbonMonoxideDetector.h @@ -0,0 +1,33 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include "caps/iot_caps_helper_carbonMonoxideDetector.h" + +typedef struct caps_carbonMonoxideDetector_data { + IOT_CAP_HANDLE* handle; + void *usr_data; + + char *carbonMonoxide_value; + const char *(*get_carbonMonoxide_value)(struct caps_carbonMonoxideDetector_data *caps_data); + void (*set_carbonMonoxide_value)(struct caps_carbonMonoxideDetector_data *caps_data, const char* value); + void (*attr_carbonMonoxide_send)(struct caps_carbonMonoxideDetector_data *caps_data); + + void (*init_usr_cb)(struct caps_carbonMonoxideDetector_data *caps_data); +} caps_carbonMonoxideDetector_data_t; + +caps_carbonMonoxideDetector_data_t *caps_carbonMonoxideDetector_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data); diff --git a/apps/esp8266/st_air_monitor/main/caps_formaldehydeMeasurement.c b/apps/esp8266/st_air_monitor/main/caps_formaldehydeMeasurement.c new file mode 100644 index 00000000..fccfb9ec --- /dev/null +++ b/apps/esp8266/st_air_monitor/main/caps_formaldehydeMeasurement.c @@ -0,0 +1,112 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include + +#include "st_dev.h" +#include "caps_formaldehydeMeasurement.h" + +#include "freertos/FreeRTOS.h" + +static int caps_formaldehydeMeasurement_get_formaldehydeLevel_value(caps_formaldehydeMeasurement_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->formaldehydeLevel_value; +} + +static void caps_formaldehydeMeasurement_set_formaldehydeLevel_value(caps_formaldehydeMeasurement_data_t *caps_data, int value) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->formaldehydeLevel_value = value; +} + +static const char *caps_formaldehydeMeasurement_get_formaldehydeLevel_unit(caps_formaldehydeMeasurement_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->formaldehydeLevel_unit; +} + +static void caps_formaldehydeMeasurement_set_formaldehydeLevel_unit(caps_formaldehydeMeasurement_data_t *caps_data, const char *unit) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->formaldehydeLevel_unit = (char *)unit; +} + +static void caps_formaldehydeMeasurement_attr_formaldehydeLevel_send(caps_formaldehydeMeasurement_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int sequence_no; + + cap_evt = st_cap_attr_create_int((char *) caps_helper_formaldehydeMeasurement.attr_formaldehydeLevel.name, caps_data->formaldehydeLevel_value, caps_data->formaldehydeLevel_unit); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send formaldehydeLevel value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + +static void caps_formaldehydeMeasurement_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) +{ + caps_formaldehydeMeasurement_data_t *caps_data = usr_data; + if (caps_data && caps_data->init_usr_cb) + caps_data->init_usr_cb(caps_data); + caps_formaldehydeMeasurement_attr_formaldehydeLevel_send(caps_data); +} + +caps_formaldehydeMeasurement_data_t *caps_formaldehydeMeasurement_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data) +{ + caps_formaldehydeMeasurement_data_t *caps_data = NULL; + + caps_data = malloc(sizeof(caps_formaldehydeMeasurement_data_t)); + if (!caps_data) { + printf("fail to malloc for caps_formaldehydeMeasurement_data\n"); + return NULL; + } + + memset(caps_data, 0, sizeof(caps_formaldehydeMeasurement_data_t)); + + caps_data->handle = st_cap_handle_init(ctx, component, caps_helper_formaldehydeMeasurement.id, caps_formaldehydeMeasurement_init_cb, caps_data); + caps_data->init_usr_cb = init_usr_cb; + caps_data->usr_data = usr_data; + + caps_data->get_formaldehydeLevel_value = caps_formaldehydeMeasurement_get_formaldehydeLevel_value; + caps_data->set_formaldehydeLevel_value = caps_formaldehydeMeasurement_set_formaldehydeLevel_value; + caps_data->get_formaldehydeLevel_unit = caps_formaldehydeMeasurement_get_formaldehydeLevel_unit; + caps_data->set_formaldehydeLevel_unit = caps_formaldehydeMeasurement_set_formaldehydeLevel_unit; + caps_data->attr_formaldehydeLevel_send = caps_formaldehydeMeasurement_attr_formaldehydeLevel_send; + + caps_data->formaldehydeLevel_value = caps_helper_formaldehydeMeasurement.attr_formaldehydeLevel.min; + caps_data->formaldehydeLevel_unit = (char *)caps_helper_formaldehydeMeasurement.attr_formaldehydeLevel.units[CAPS_HELPER_FORMALDEHYDE_MEASUREMENT_UNIT_PPM]; + + return caps_data; +} diff --git a/apps/esp8266/st_air_monitor/main/caps_formaldehydeMeasurement.h b/apps/esp8266/st_air_monitor/main/caps_formaldehydeMeasurement.h new file mode 100644 index 00000000..33cd28c1 --- /dev/null +++ b/apps/esp8266/st_air_monitor/main/caps_formaldehydeMeasurement.h @@ -0,0 +1,36 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include "caps/iot_caps_helper_formaldehydeMeasurement.h" + +typedef struct caps_formaldehydeMeasurement_data { + IOT_CAP_HANDLE* handle; + void *usr_data; + + int formaldehydeLevel_value; + int (*get_formaldehydeLevel_value)(struct caps_formaldehydeMeasurement_data *caps_data); + void (*set_formaldehydeLevel_value)(struct caps_formaldehydeMeasurement_data *caps_data, int value); + char *formaldehydeLevel_unit; + const char *(*get_formaldehydeLevel_unit)(struct caps_formaldehydeMeasurement_data *caps_data); + void (*set_formaldehydeLevel_unit)(struct caps_formaldehydeMeasurement_data *caps_data, const char *unit); + void (*attr_formaldehydeLevel_send)(struct caps_formaldehydeMeasurement_data *caps_data); + + void (*init_usr_cb)(struct caps_formaldehydeMeasurement_data *caps_data); +} caps_formaldehydeMeasurement_data_t; + +caps_formaldehydeMeasurement_data_t *caps_formaldehydeMeasurement_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data); diff --git a/apps/esp8266/st_air_monitor/main/smart_air_monitor.c b/apps/esp8266/st_air_monitor/main/smart_air_monitor.c index 7ca2e65d..da832ab0 100755 --- a/apps/esp8266/st_air_monitor/main/smart_air_monitor.c +++ b/apps/esp8266/st_air_monitor/main/smart_air_monitor.c @@ -18,14 +18,20 @@ //for implementing main features of IoT device #include +#include #include "st_dev.h" -#include "device_control.h" #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "driver/gpio.h" +#include "caps_airQualitySensor.h" +#include "caps_alarm.h" +#include "caps_carbonDioxideMeasurement.h" +#include "caps_carbonMonoxideDetector.h" +#include "caps_formaldehydeMeasurement.h" + // onboarding_config_start is null-terminated string extern const uint8_t onboarding_config_start[] asm("_binary_onboarding_config_json_start"); extern const uint8_t onboarding_config_end[] asm("_binary_onboarding_config_json_end"); @@ -35,35 +41,61 @@ extern const uint8_t device_info_start[] asm("_binary_device_info_json_start"); extern const uint8_t device_info_end[] asm("_binary_device_info_json_end"); static iot_status_t g_iot_status; - -static int noti_led_mode = LED_ANIMATION_MODE_IDLE; +static iot_stat_lv_t g_iot_stat_lv; IOT_CTX *ctx = NULL; -IOT_CAP_HANDLE* alarm_handle = NULL; -IOT_CAP_HANDLE* air_quality_handle = NULL; -IOT_CAP_HANDLE* carbon_dioxide_handle = NULL; -IOT_CAP_HANDLE* carbon_monoxide_handle = NULL; -IOT_CAP_HANDLE* formaldehyde_handle = NULL; +struct caps_airQualitySensor_data *cap_airQualitySensor_data; +struct caps_alarm_data *cap_alarm_data; +struct caps_carbonDioxideMeasurement_data *cap_carbonDioxideMeasurement_data; +struct caps_carbonMonoxideDetector_data *cap_carbonMonoxideDetector_data; +struct caps_formaldehydeMeasurement_data *cap_formaldehydeMeasurement_data; -enum { - ALARM_STATE_OFF = 0, - ALARM_STATE_BOTH, - ALARM_STATE_SIREN, - ALARM_STATE_STROBE, -}; +void change_siren_state(int onoff) +{ + /* + * YOUR CODE: + */ +} -int g_alarm_state = ALARM_STATE_OFF; +void change_strobe_state(int onoff) +{ + /* + * YOUR CODE: + */ +} +void change_alarm_state(int state) +{ + switch(state) + { + case CAPS_HELPER_ALARM_VALUE_BOTH: + change_siren_state(1); + change_strobe_state(1); + break; + case CAPS_HELPER_ALARM_VALUE_SIREN: + change_siren_state(1); + change_strobe_state(0); + break; + case CAPS_HELPER_ALARM_VALUE_STROBE: + change_siren_state(0); + change_strobe_state(1); + break; + case CAPS_HELPER_ALARM_VALUE_OFF: + change_siren_state(0); + change_strobe_state(0); + break; + default: + change_siren_state(0); + change_strobe_state(0); + printf("Error: unexpected alarm state : %d\n", state); + } +} /* dummy value for test */ #define AIR_QUALITY_THRESHOLD 50 #define CARBON_DIOXIDE_THRESHOLD 500 -#define CARBON_MONOXIDE_THRESHOLD 1 +#define CARBON_MONOXIDE_THRESHOLD 100 #define FORMALDEHYDE_THRESHOLD 500 -int g_air_quality_value = 25; -int g_carbon_dioxide_value= 250; -int g_carbon_monoxide_value = 0; -int g_formaldehyde_value = 250; int get_air_quality(void) { @@ -71,8 +103,9 @@ int get_air_quality(void) * YOUR CODE: * implement a ability to obtain the value from your sensor */ + int air_quality_value = 80; - return g_air_quality_value; + return air_quality_value; } int get_carbon_dioxide(void) @@ -81,8 +114,9 @@ int get_carbon_dioxide(void) * YOUR CODE: * implement a ability to obtain the value from your sensor */ + int carbon_dioxide_value = 300; - return g_carbon_dioxide_value; + return carbon_dioxide_value; } int get_carbon_monoxide(void) @@ -91,8 +125,17 @@ int get_carbon_monoxide(void) * YOUR CODE: * implement a ability to obtain the value from your sensor */ + int carbon_monoxide_value = 70; + + return carbon_monoxide_value; +} - return g_carbon_monoxide_value; +const char* get_carbon_monoxide_state(void) +{ + if (get_carbon_monoxide() > CARBON_MONOXIDE_THRESHOLD) { + return caps_helper_carbonMonoxideDetector.attr_carbonMonoxide.values[CAPS_HELPER_CARBON_MONOXIDE_DETECTOR_VALUE_DETECTED]; + } + return caps_helper_carbonMonoxideDetector.attr_carbonMonoxide.values[CAPS_HELPER_CARBON_MONOXIDE_DETECTOR_VALUE_CLEAR]; } int get_formaldehyde(void) @@ -101,181 +144,75 @@ int get_formaldehyde(void) * YOUR CODE: * implement a ability to obtain the value from your sensor */ + int formaldehyde_value = 200; - return g_formaldehyde_value; + return formaldehyde_value; } int get_alarm_state(void) { - return g_alarm_state; -} - -void change_alarm_state(int state) -{ - switch(state) - { - case ALARM_STATE_BOTH: - change_siren_state(1); - change_strobe_state(1); - break; - case ALARM_STATE_SIREN: - change_siren_state(1); - change_strobe_state(0); - break; - case ALARM_STATE_STROBE: - change_siren_state(0); - change_strobe_state(1); - break; - case ALARM_STATE_OFF: - change_siren_state(0); - change_strobe_state(0); - break; - default: - change_siren_state(0); - change_strobe_state(0); - printf("error: unexpected alarm state : %d\n", state); + int alarm_state; + if ( (AIR_QUALITY_THRESHOLD > cap_airQualitySensor_data->get_airQuality_value(cap_airQualitySensor_data)) + || (CARBON_DIOXIDE_THRESHOLD < cap_carbonDioxideMeasurement_data->get_carbonDioxide_value(cap_carbonDioxideMeasurement_data)) + || (FORMALDEHYDE_THRESHOLD < cap_formaldehydeMeasurement_data->get_formaldehydeLevel_value(cap_formaldehydeMeasurement_data)) + || (!strcmp(cap_carbonMonoxideDetector_data->get_carbonMonoxide_value(cap_carbonMonoxideDetector_data), caps_helper_carbonMonoxideDetector.attr_carbonMonoxide.values[CAPS_HELPER_CARBON_MONOXIDE_DETECTOR_VALUE_DETECTED]))) { + alarm_state = CAPS_HELPER_ALARM_VALUE_BOTH; + } else { + alarm_state = CAPS_HELPER_ALARM_VALUE_OFF; } - g_alarm_state = state; + + return alarm_state; } -void send_alarm_capability(int state) +void cap_alarm_init_cb(struct caps_alarm_data *caps_data) { - IOT_CAP_HANDLE *handle = alarm_handle; - IOT_EVENT *cap_evt; - int32_t sequence_no; - switch(state) - { - case ALARM_STATE_BOTH: - cap_evt = st_cap_attr_create_string("alarm", "both", NULL); - break; - case ALARM_STATE_SIREN: - cap_evt = st_cap_attr_create_string("alarm", "siren", NULL); - break; - case ALARM_STATE_STROBE: - cap_evt = st_cap_attr_create_string("alarm", "strobe", NULL); - break; - case ALARM_STATE_OFF: - cap_evt = st_cap_attr_create_string("alarm", "off", NULL); - break; - default: - printf("error: unexpected alarm state : %d\n", state); - cap_evt = st_cap_attr_create_string("alarm", "off", NULL); - } - - sequence_no = st_cap_attr_send(handle, 1, &cap_evt); - if (sequence_no < 0) - printf("fail to send data\n"); - - printf("Sequence number return : %d\n", sequence_no); - st_cap_attr_free(cap_evt); + caps_data->set_alarm_value(caps_data, caps_helper_alarm.attr_alarm.values[CAPS_HELPER_ALARM_VALUE_OFF]); } -void send_air_quality_capability(int value) +void cap_airQualitySensor_init_cb(struct caps_airQualitySensor_data *caps_data) { - IOT_CAP_HANDLE *handle = air_quality_handle; - IOT_EVENT *cap_evt; - int32_t sequence_no; - - cap_evt = st_cap_attr_create_int("airQuality", value, "CAQI"); - sequence_no = st_cap_attr_send(handle, 1, &cap_evt); - if (sequence_no < 0) - printf("fail to send data\n"); - - printf("Sequence number return : %d\n", sequence_no); - st_cap_attr_free(cap_evt); + caps_data->set_airQuality_value(caps_data, get_air_quality()); + caps_data->set_airQuality_unit(caps_data, caps_helper_airQualitySensor.attr_airQuality.units[CAPS_HELPER_AIR_QUALITY_SENSOR_UNIT_CAQI]); } -void send_carbon_dioxide_capability(int value) +void cap_carbonDioxideMeasurement_init_cb(struct caps_carbonDioxideMeasurement_data *caps_data) { - IOT_CAP_HANDLE *handle = carbon_dioxide_handle; - IOT_EVENT *cap_evt; - int32_t sequence_no; - - cap_evt = st_cap_attr_create_int("carbonDioxide", value, "ppm"); - sequence_no = st_cap_attr_send(handle, 1, &cap_evt); - if (sequence_no < 0) - printf("fail to send data\n"); - - printf("Sequence number return : %d\n", sequence_no); - st_cap_attr_free(cap_evt); + caps_data->set_carbonDioxide_value(caps_data, get_carbon_dioxide()); + caps_data->set_carbonDioxide_unit(caps_data, caps_helper_carbonDioxideMeasurement.attr_carbonDioxide.units[CAPS_HELPER_CARBON_DIOXIDE_MEASUREMENT_UNIT_PPM]); } -void send_carbon_monoxide_capability(int value) +void cap_carbonMonoxideDetector_init_cb(struct caps_carbonMonoxideDetector_data *caps_data) { - IOT_CAP_HANDLE *handle = carbon_monoxide_handle; - IOT_EVENT *cap_evt; - int32_t sequence_no; - - if (value) - cap_evt = st_cap_attr_create_string("carbonMonoxide", "detected", NULL); - else - cap_evt = st_cap_attr_create_string("carbonMonoxide", "clear", NULL); - - sequence_no = st_cap_attr_send(handle, 1, &cap_evt); - if (sequence_no < 0) - printf("fail to send data\n"); - - printf("Sequence number return : %d\n", sequence_no); - st_cap_attr_free(cap_evt); + caps_data->set_carbonMonoxide_value(caps_data, get_carbon_monoxide_state()); } -void send_formaldehyde_capability(int value) +void cap_formaldehydeMeasurement_init_cb(struct caps_formaldehydeMeasurement_data *caps_data) { - IOT_CAP_HANDLE *handle = formaldehyde_handle; - IOT_EVENT *cap_evt; - int32_t sequence_no; - - cap_evt = st_cap_attr_create_int("formaldehydeLevel", value, "ppm"); - - sequence_no = st_cap_attr_send(handle, 1, &cap_evt); - if (sequence_no < 0) - printf("fail to send data\n"); - - printf("Sequence number return : %d\n", sequence_no); - st_cap_attr_free(cap_evt); + caps_data->set_formaldehydeLevel_value(caps_data, get_formaldehyde()); + caps_data->set_formaldehydeLevel_unit(caps_data, caps_helper_formaldehydeMeasurement.attr_formaldehydeLevel.units[CAPS_HELPER_FORMALDEHYDE_MEASUREMENT_UNIT_PPM]); } - -static void button_event(uint32_t type, uint32_t count) +void cap_alarm_cmd_cb(struct caps_alarm_data *caps_data) { - if (type == BUTTON_SHORT_PRESS) { - printf("Button short press, count: %d\n", count); - switch(count) { - case 1: - change_alarm_state(ALARM_STATE_OFF); - send_alarm_capability(ALARM_STATE_OFF); - break; - default: - led_blink(GPIO_OUTPUT_NOTIFICATION_LED, 100, count); - break; + const char *alarm_value = caps_data->get_alarm_value(caps_data); + int alarm_state; + + for (alarm_state = 0; alarm_state < CAPS_HELPER_ALARM_VALUE_MAX; alarm_state++) { + if (!strcmp(alarm_value, caps_helper_alarm.attr_alarm.values[alarm_state])) { + change_alarm_state(alarm_state); + return; } - } else if (type == BUTTON_LONG_PRESS) { - printf("Button long press, count: %d\n", count); - led_blink(GPIO_OUTPUT_NOTIFICATION_LED, 100, 3); - /* clean-up provisioning & registered data with reboot option*/ - st_conn_cleanup(ctx, true); } + printf("Error: unexpected alarm value %s\n", alarm_value); } static void iot_status_cb(iot_status_t status, - iot_stat_lv_t stat_lv, void *usr_data) + iot_stat_lv_t stat_lv, void *usr_data) { g_iot_status = status; - printf("iot_status: %d, lv: %d\n", status, stat_lv); + g_iot_stat_lv = stat_lv; - switch(status) - { - case IOT_STATUS_NEED_INTERACT: - noti_led_mode = LED_ANIMATION_MODE_FAST; - break; - case IOT_STATUS_IDLE: - case IOT_STATUS_CONNECTING: - noti_led_mode = LED_ANIMATION_MODE_IDLE; - gpio_set_level(GPIO_OUTPUT_NOTIFICATION_LED, NOTIFICATION_LED_GPIO_ON); - break; - default: - break; - } + printf("status: %d, stat: %d\n", g_iot_status, g_iot_stat_lv); } void iot_noti_cb(iot_noti_data_t *noti_data, void *noti_usr_data) @@ -290,116 +227,52 @@ void iot_noti_cb(iot_noti_data_t *noti_data, void *noti_usr_data) } } -#define MONITOR_DELAY_MS 60000 -static void app_task(void *arg) +void update_air_monitor_info(void) { - int button_event_type; - int button_event_count; + cap_airQualitySensor_data->set_airQuality_value(cap_airQualitySensor_data, get_air_quality()); + cap_carbonDioxideMeasurement_data->set_carbonDioxide_value(cap_carbonDioxideMeasurement_data, get_carbon_dioxide()); + cap_carbonMonoxideDetector_data->set_carbonMonoxide_value(cap_carbonMonoxideDetector_data, get_carbon_monoxide_state()); + cap_formaldehydeMeasurement_data->set_formaldehydeLevel_value(cap_formaldehydeMeasurement_data, get_formaldehyde()); +} - int air_quality_value; - int carbon_dioxide_value; - int carbon_monoxide_value; - int formaldehyde_value; - int alarm_state; +void update_alarm_state(void) +{ + int alarm_state = get_alarm_state(); + change_alarm_state(alarm_state); + cap_alarm_data->set_alarm_value(cap_alarm_data, caps_helper_alarm.attr_alarm.values[alarm_state]); +} + +void send_air_monitor_info(void) +{ + cap_alarm_data->attr_alarm_send(cap_alarm_data); + cap_airQualitySensor_data->attr_airQuality_send(cap_airQualitySensor_data); + cap_carbonDioxideMeasurement_data->attr_carbonDioxide_send(cap_carbonDioxideMeasurement_data); + cap_carbonMonoxideDetector_data->attr_carbonMonoxide_send(cap_carbonMonoxideDetector_data); + cap_formaldehydeMeasurement_data->attr_formaldehydeLevel_send(cap_formaldehydeMeasurement_data); +} +#define MONITOR_DELAY_MS 60000 +static void app_task(void *arg) +{ TimeOut_t monitor_timeout; TickType_t monitor_delay_tick = pdMS_TO_TICKS(MONITOR_DELAY_MS); vTaskSetTimeOutState(&monitor_timeout); for (;;) { - if (get_button_event(&button_event_type, &button_event_count)) { - button_event(button_event_type, button_event_count); - } - if (xTaskCheckForTimeOut(&monitor_timeout, &monitor_delay_tick ) != pdFALSE) { vTaskSetTimeOutState(&monitor_timeout); monitor_delay_tick = pdMS_TO_TICKS(MONITOR_DELAY_MS); - air_quality_value = get_air_quality(); - carbon_dioxide_value= get_carbon_dioxide(); - carbon_monoxide_value = get_carbon_monoxide(); - formaldehyde_value = get_formaldehyde(); - - if ( (air_quality_value >= AIR_QUALITY_THRESHOLD) || - (carbon_dioxide_value >= CARBON_DIOXIDE_THRESHOLD) || - (carbon_monoxide_value >= CARBON_MONOXIDE_THRESHOLD) || - (formaldehyde_value >= FORMALDEHYDE_THRESHOLD) ) { - alarm_state = ALARM_STATE_BOTH; - } else { - alarm_state = ALARM_STATE_OFF; - } + update_air_monitor_info(); + update_alarm_state(); - change_alarm_state(alarm_state); - send_alarm_capability(alarm_state); - send_air_quality_capability(air_quality_value); - send_carbon_dioxide_capability(carbon_dioxide_value); - send_carbon_monoxide_capability(carbon_monoxide_value); - send_formaldehyde_capability(formaldehyde_value); - } - - if (noti_led_mode != LED_ANIMATION_MODE_IDLE) { - change_led_state(noti_led_mode); + send_air_monitor_capabilities(); } vTaskDelay(10 / portTICK_PERIOD_MS); } } -/* capability command callback functions */ -void cap_alarm_cmd_both_cb(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) -{ - change_alarm_state(ALARM_STATE_BOTH); - send_alarm_capability(ALARM_STATE_BOTH); -} - -void cap_alarm_cmd_siren_cb(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) -{ - change_alarm_state(ALARM_STATE_SIREN); - send_alarm_capability(ALARM_STATE_SIREN); -} - -void cap_alarm_cmd_strobe_cb(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) -{ - change_alarm_state(ALARM_STATE_STROBE); - send_alarm_capability(ALARM_STATE_STROBE); -} - -void cap_alarm_cmd_off_cb(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) -{ - change_alarm_state(ALARM_STATE_OFF); - send_alarm_capability(ALARM_STATE_OFF); -} - -/* capability init callback functions */ -void cap_alarm_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) -{ - send_alarm_capability(get_alarm_state()); -} - -void cap_air_quality_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) -{ - send_air_quality_capability(get_air_quality()); -} - -void cap_carbon_dioxide_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) -{ - send_carbon_dioxide_capability(get_carbon_dioxide()); -} - -void cap_carbon_monoxide_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) -{ - send_carbon_monoxide_capability(get_carbon_monoxide()); -} - -void cap_formaldehyde_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) -{ - send_formaldehyde_capability(get_formaldehyde()); -} - void app_main(void) { /** @@ -432,41 +305,31 @@ void app_main(void) int iot_err; + // 1. create a iot context ctx = st_conn_init(onboarding_config, onboarding_config_len, device_info, device_info_len); if (ctx != NULL) { iot_err = st_conn_set_noti_cb(ctx, iot_noti_cb, NULL); if (iot_err) printf("fail to set notification callback function\n"); - - alarm_handle = st_cap_handle_init(ctx, "main", "alarm", cap_alarm_init_cb, NULL); - iot_err = st_cap_cmd_set_cb(alarm_handle, "both", cap_alarm_cmd_both_cb, NULL); - if (iot_err) - printf("fail to set cmd_cb for off\n"); - iot_err = st_cap_cmd_set_cb(alarm_handle, "off", cap_alarm_cmd_off_cb, NULL); - if (iot_err) - printf("fail to set cmd_cb for off\n"); - iot_err = st_cap_cmd_set_cb(alarm_handle, "siren", cap_alarm_cmd_siren_cb, NULL); - if (iot_err) - printf("fail to set cmd_cb for off\n"); - iot_err = st_cap_cmd_set_cb(alarm_handle, "strobe", cap_alarm_cmd_strobe_cb, NULL); - if (iot_err) - printf("fail to set cmd_cb for off\n"); - - air_quality_handle = st_cap_handle_init(ctx, "main", "airQualitySensor", - cap_air_quality_init_cb, NULL); - carbon_dioxide_handle = st_cap_handle_init(ctx, "main", "carbonDioxideMeasurement", - cap_carbon_dioxide_init_cb, NULL); - carbon_monoxide_handle = st_cap_handle_init(ctx, "main", "carbonMonoxideDetector", - cap_carbon_monoxide_init_cb, NULL); - formaldehyde_handle = st_cap_handle_init(ctx, "main", "formaldehydeMeasurement", - cap_formaldehyde_init_cb, NULL); + // 2. create a handle to process capability + // implement init_callback function + cap_alarm_data = caps_alarm_initialize(ctx, "main", cap_alarm_init_cb, NULL); + cap_airQualitySensor_data = caps_airQualitySensor_initialize(ctx, "main", cap_airQualitySensor_init_cb, NULL); + cap_carbonDioxideMeasurement_data = caps_carbonDioxideMeasurement_initialize(ctx, "main", cap_carbonDioxideMeasurement_init_cb, NULL); + cap_carbonMonoxideDetector_data = caps_carbonMonoxideDetector_initialize(ctx, "main", cap_carbonMonoxideDetector_init_cb, NULL); + cap_formaldehydeMeasurement_data = caps_formaldehydeMeasurement_initialize(ctx, "main", cap_formaldehydeMeasurement_init_cb, NULL); + + // 3. register a callback function to process capability command when it comes from the SmartThings Server + // implement callback function + cap_alarm_data->cmd_both_usr_cb = cap_alarm_cmd_cb; + cap_alarm_data->cmd_off_usr_cb = cap_alarm_cmd_cb; + cap_alarm_data->cmd_siren_usr_cb = cap_alarm_cmd_cb; + cap_alarm_data->cmd_strobe_usr_cb = cap_alarm_cmd_cb; } else { printf("fail to create the iot_context\n"); } - gpio_init(); - // 4. needed when it is necessary to keep monitoring the device status xTaskCreate(app_task, "app_task", 2048, NULL, 10, NULL); diff --git a/apps/esp8266/st_lamp/main/caps_colorControl.c b/apps/esp8266/st_lamp/main/caps_colorControl.c new file mode 100644 index 00000000..c5ecb13f --- /dev/null +++ b/apps/esp8266/st_lamp/main/caps_colorControl.c @@ -0,0 +1,198 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include + +#include "st_dev.h" +#include "caps_colorControl.h" + +#include "freertos/FreeRTOS.h" + +static double caps_colorControl_get_hue_value(caps_colorControl_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return -1; + } + return caps_data->hue_value; +} + +static double caps_colorControl_get_saturation_value(caps_colorControl_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return -1; + } + return caps_data->saturation_value; +} + +static void caps_colorControl_set_color_value(caps_colorControl_data_t *caps_data, double hue, double saturation) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + + caps_data->hue_value = hue; + caps_data->saturation_value = saturation; +} + +static void caps_colorControl_set_hue_value(caps_colorControl_data_t *caps_data, double hue) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + + caps_data->hue_value = hue; +} + +static void caps_colorControl_set_saturation_value(caps_colorControl_data_t *caps_data, double saturation) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + + caps_data->saturation_value = saturation; +} + +static void caps_colorControl_attr_color_send(caps_colorControl_data_t *caps_data) +{ + IOT_EVENT *cap_evt[2]; + uint8_t evt_num = 2; + int32_t sequence_no; + + cap_evt[0] = st_cap_attr_create_number((char *) caps_helper_colorControl.attr_hue.name, caps_data->hue_value, NULL); + cap_evt[1] = st_cap_attr_create_number((char *) caps_helper_colorControl.attr_saturation.name, caps_data->saturation_value, NULL); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, cap_evt); + if (sequence_no < 0) + printf("fail to send color data\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt[0]); + st_cap_attr_free(cap_evt[1]); +} + +static void caps_colorControl_cmd_setColor_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_colorControl_data_t *caps_data = usr_data; + double hue, saturation; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + saturation = cmd_data->cmd_data[0].number; + hue = cmd_data->cmd_data[1].number; + + caps_colorControl_set_color_value(caps_data, hue, saturation); + if (caps_data && caps_data->cmd_setColor_usr_cb) + caps_data->cmd_setColor_usr_cb(caps_data); + caps_colorControl_attr_color_send(caps_data); +} + +static void caps_colorControl_cmd_setHue_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_colorControl_data_t *caps_data = usr_data; + double hue; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + hue = cmd_data->cmd_data[0].number; + + caps_colorControl_set_hue_value(caps_data, hue); + if (caps_data && caps_data->cmd_setHue_usr_cb) + caps_data->cmd_setHue_usr_cb(caps_data); + caps_colorControl_attr_color_send(caps_data); +} + +static void caps_colorControl_cmd_setSaturation_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_colorControl_data_t *caps_data = usr_data; + double saturation; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + saturation = cmd_data->cmd_data[0].number; + + caps_colorControl_set_saturation_value(caps_data, saturation); + if (caps_data && caps_data->cmd_setSaturation_usr_cb) + caps_data->cmd_setSaturation_usr_cb(caps_data); + caps_colorControl_attr_color_send(caps_data); +} + +static void caps_colorControl_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) +{ + caps_colorControl_data_t *caps_data = usr_data; + if (caps_data && caps_data->init_usr_cb) + caps_data->init_usr_cb(caps_data); + caps_colorControl_attr_color_send(caps_data); +} + +caps_colorControl_data_t *caps_colorControl_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data) +{ + caps_colorControl_data_t *caps_data = NULL; + int err; + + caps_data = malloc(sizeof(caps_colorControl_data_t)); + if (!caps_data) { + printf("fail to malloc for caps_colorControl_data\n"); + return NULL; + } + + memset(caps_data, 0, sizeof(caps_colorControl_data_t)); + + caps_data->handle = st_cap_handle_init(ctx, component, caps_helper_colorControl.id, caps_colorControl_init_cb, caps_data); + caps_data->init_usr_cb = init_usr_cb; + caps_data->usr_data = usr_data; + + caps_data->get_hue_value = caps_colorControl_get_hue_value; + caps_data->get_saturation_value = caps_colorControl_get_saturation_value; + caps_data->set_color_value = caps_colorControl_set_color_value; + caps_data->set_hue_value = caps_colorControl_set_hue_value; + caps_data->set_saturation_value = caps_colorControl_set_saturation_value; + caps_data->attr_color_send = caps_colorControl_attr_color_send; + + + caps_data->hue_value = caps_helper_colorControl.attr_hue.min; + caps_data->saturation_value = caps_helper_colorControl.attr_saturation.min; + + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_colorControl.cmd_setColor.name, caps_colorControl_cmd_setColor_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for setColor\n"); + return NULL; + } + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_colorControl.cmd_setHue.name, caps_colorControl_cmd_setHue_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for setHue\n"); + return NULL; + } + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_colorControl.cmd_setSaturation.name, caps_colorControl_cmd_setSaturation_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for setSaturation\n"); + return NULL; + } + + return caps_data; +} diff --git a/apps/esp8266/st_lamp/main/caps_colorControl.h b/apps/esp8266/st_lamp/main/caps_colorControl.h new file mode 100644 index 00000000..29bd99ee --- /dev/null +++ b/apps/esp8266/st_lamp/main/caps_colorControl.h @@ -0,0 +1,42 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include "caps/iot_caps_helper_colorControl.h" + +typedef struct caps_colorControl_data { + IOT_CAP_HANDLE* handle; + void *usr_data; + + double hue_value; + double saturation_value; + + double (*get_hue_value)(struct caps_colorControl_data *caps_data); + double (*get_saturation_value)(struct caps_colorControl_data *caps_data); + void (*set_color_value)(struct caps_colorControl_data *caps_data, double hue, double saturation); + void (*set_hue_value)(struct caps_colorControl_data *caps_data, double hue); + void (*set_saturation_value)(struct caps_colorControl_data *caps_data, double saturation); + void (*attr_color_send)(struct caps_colorControl_data *caps_data); + + void (*init_usr_cb)(struct caps_colorControl_data *caps_data); + + void (*cmd_setColor_usr_cb)(struct caps_colorControl_data *caps_data); + void (*cmd_setHue_usr_cb)(struct caps_colorControl_data *caps_data); + void (*cmd_setSaturation_usr_cb)(struct caps_colorControl_data *caps_data); +} caps_colorControl_data_t; + +caps_colorControl_data_t *caps_colorControl_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data); diff --git a/apps/esp8266/st_lamp/main/caps_switch.c b/apps/esp8266/st_lamp/main/caps_switch.c new file mode 100644 index 00000000..f419e1fa --- /dev/null +++ b/apps/esp8266/st_lamp/main/caps_switch.c @@ -0,0 +1,134 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include + +#include "st_dev.h" +#include "caps_switch.h" + +#include "freertos/FreeRTOS.h" + +static const char *caps_switch_get_switch_value(caps_switch_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->switch_value; +} + +static void caps_switch_set_switch_value(caps_switch_data_t *caps_data, const char *value) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->switch_value = (char *)value; +} + +static void caps_switch_attr_switch_send(caps_switch_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int sequence_no; + + cap_evt = st_cap_attr_create_string((char *)caps_helper_switch.attr_switch.name, + caps_data->switch_value, NULL); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send switch value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + + +static void caps_switch_cmd_off_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_switch_data_t *caps_data = (caps_switch_data_t *)usr_data; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_switch_set_switch_value(caps_data, caps_helper_switch.attr_switch.values[CAPS_HELPER_SWITCH_VALUE_OFF]); + if (caps_data && caps_data->cmd_off_usr_cb) + caps_data->cmd_off_usr_cb(caps_data); + caps_switch_attr_switch_send(caps_data); +} + + +static void caps_switch_cmd_on_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_switch_data_t *caps_data = (caps_switch_data_t *)usr_data; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_switch_set_switch_value(caps_data, caps_helper_switch.attr_switch.values[CAPS_HELPER_SWITCH_VALUE_ON]); + if (caps_data && caps_data->cmd_off_usr_cb) + caps_data->cmd_off_usr_cb(caps_data); + caps_switch_attr_switch_send(caps_data); +} + +static void caps_switch_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) +{ + caps_switch_data_t *caps_data = usr_data; + if (caps_data && caps_data->init_usr_cb) + caps_data->init_usr_cb(caps_data); + caps_switch_attr_switch_send(caps_data); +} + +caps_switch_data_t *caps_switch_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data) +{ + caps_switch_data_t *caps_data = NULL; + int err; + + caps_data = malloc(sizeof(caps_switch_data_t)); + if (!caps_data) { + printf("fail to malloc for caps_switch_data\n"); + return NULL; + } + + memset(caps_data, 0, sizeof(caps_switch_data_t)); + + caps_data->handle = st_cap_handle_init(ctx, component, caps_helper_switch.id , caps_switch_init_cb, caps_data); + caps_data->init_usr_cb = init_usr_cb; + caps_data->usr_data = usr_data; + + caps_data->get_switch_value = caps_switch_get_switch_value; + caps_data->set_switch_value = caps_switch_set_switch_value; + caps_data->attr_switch_send = caps_switch_attr_switch_send; + + caps_data->switch_value = (char *)caps_helper_switch.attr_switch.values[CAPS_HELPER_SWITCH_VALUE_ON]; + + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_switch.cmd_off.name, caps_switch_cmd_off_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for off\n"); + return NULL; + } + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_switch.cmd_on.name, caps_switch_cmd_on_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for on\n"); + return NULL; + } + + return caps_data; +} diff --git a/apps/esp8266/st_lamp/main/caps_switch.h b/apps/esp8266/st_lamp/main/caps_switch.h new file mode 100644 index 00000000..89e7488c --- /dev/null +++ b/apps/esp8266/st_lamp/main/caps_switch.h @@ -0,0 +1,36 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include "caps/iot_caps_helper_switch.h" + +typedef struct caps_switch_data { + IOT_CAP_HANDLE* handle; + void *usr_data; + + char *switch_value; + const char *(*get_switch_value)(struct caps_switch_data *caps_data); + void (*set_switch_value)(struct caps_switch_data *caps_data, const char *value); + void (*attr_switch_send)(struct caps_switch_data *caps_data); + + void (*init_usr_cb)(struct caps_switch_data *caps_data); + + void (*cmd_on_usr_cb)(struct caps_switch_data *caps_data); + void (*cmd_off_usr_cb)(struct caps_switch_data *caps_data); +} caps_switch_data_t; + +caps_switch_data_t *caps_switch_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data); diff --git a/apps/esp8266/st_lamp/main/caps_switchLevel.c b/apps/esp8266/st_lamp/main/caps_switchLevel.c new file mode 100644 index 00000000..4fdd200a --- /dev/null +++ b/apps/esp8266/st_lamp/main/caps_switchLevel.c @@ -0,0 +1,138 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include + +#include "st_dev.h" +#include "caps_switchLevel.h" + +#include "freertos/FreeRTOS.h" + +static int caps_switchLevel_get_level_value(caps_switchLevel_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return -1; + } + return caps_data->level_value; +} + +static void caps_switchLevel_set_level_value(caps_switchLevel_data_t *caps_data, int value) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->level_value = value; +} + +static const char *caps_switchLevel_get_level_unit(caps_switchLevel_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->level_unit; +} + +static void caps_switchLevel_set_level_unit(caps_switchLevel_data_t *caps_data, const char *unit) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + + caps_data->level_unit = (char *)unit; +} + +static void caps_switchLevel_attr_level_send(caps_switchLevel_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int32_t sequence_no; + + cap_evt = st_cap_attr_create_int((char *)caps_helper_switchLevel.attr_level.name, caps_data->level_value, caps_data->level_unit); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send level value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + +static void caps_switchLevel_cmd_set_level_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_switchLevel_data_t *caps_data = usr_data; + int level; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + level = cmd_data->cmd_data[0].number; + + caps_switchLevel_set_level_value(caps_data, level); + if (caps_data && caps_data->cmd_set_level_usr_cb) + caps_data->cmd_set_level_usr_cb(caps_data); + caps_switchLevel_attr_level_send(caps_data); +} + +static void caps_switchLevel_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) +{ + caps_switchLevel_data_t *caps_data = usr_data; + if (caps_data && caps_data->init_usr_cb) + caps_data->init_usr_cb(caps_data); + caps_switchLevel_attr_level_send(caps_data); + +} + +caps_switchLevel_data_t *caps_switchLevel_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data) +{ + caps_switchLevel_data_t *caps_data = NULL; + int err; + + caps_data = malloc(sizeof(caps_switchLevel_data_t)); + if (!caps_data) { + printf("fail to malloc for caps_switchLevel_data\n"); + return NULL; + } + + memset(caps_data, 0, sizeof(caps_switchLevel_data_t)); + + caps_data->handle = st_cap_handle_init(ctx, component, caps_helper_switchLevel.id, caps_switchLevel_init_cb, caps_data); + caps_data->init_usr_cb = init_usr_cb; + caps_data->usr_data = usr_data; + + caps_data->get_level_value = caps_switchLevel_get_level_value; + caps_data->set_level_value = caps_switchLevel_set_level_value; + caps_data->get_level_unit = caps_switchLevel_get_level_unit; + caps_data->set_level_unit = caps_switchLevel_set_level_unit; + caps_data->attr_level_send = caps_switchLevel_attr_level_send; + + caps_data->level_value = caps_helper_switchLevel.attr_level.min; + caps_data->level_unit = (char *)caps_helper_switchLevel.attr_level.units[CAPS_HELPER_SWITCH_LEVEL_UNIT_PERCENT]; + + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_switchLevel.cmd_setLevel.name, caps_switchLevel_cmd_set_level_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for setLevel\n"); + return NULL; + } + + return caps_data; +} diff --git a/apps/esp8266/st_lamp/main/caps_switchLevel.h b/apps/esp8266/st_lamp/main/caps_switchLevel.h new file mode 100644 index 00000000..0656236c --- /dev/null +++ b/apps/esp8266/st_lamp/main/caps_switchLevel.h @@ -0,0 +1,38 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include "caps/iot_caps_helper_switchLevel.h" + +typedef struct caps_switchLevel_data { + IOT_CAP_HANDLE* handle; + void *usr_data; + + int level_value; + int (*get_level_value)(struct caps_switchLevel_data *caps_data); + void (*set_level_value)(struct caps_switchLevel_data *caps_data, int value); + char *level_unit; + const char *(*get_level_unit)(struct caps_switchLevel_data *caps_data); + void (*set_level_unit)(struct caps_switchLevel_data *caps_data, const char *unit); + void (*attr_level_send)(struct caps_switchLevel_data *caps_data); + + void (*init_usr_cb)(struct caps_switchLevel_data *caps_data); + + void (*cmd_set_level_usr_cb)(struct caps_switchLevel_data *caps_data); +} caps_switchLevel_data_t; + +caps_switchLevel_data_t *caps_switchLevel_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data); diff --git a/apps/esp8266/st_lamp/main/device_control.h b/apps/esp8266/st_lamp/main/device_control.h index 8624e419..a959d9d8 100644 --- a/apps/esp8266/st_lamp/main/device_control.h +++ b/apps/esp8266/st_lamp/main/device_control.h @@ -32,6 +32,7 @@ enum notification_led_gpio_state { NOTIFICATION_LED_GPIO_ON = 0, NOTIFICATION_LED_GPIO_OFF = 1, }; + #elif defined(CONFIG_TARGET_ESP8266_DEVKITC_V1) #define GPIO_OUTPUT_NOTIFICATION_LED 2 @@ -60,8 +61,14 @@ enum notification_led_gpio_state { NOTIFICATION_LED_GPIO_ON = 0, NOTIFICATION_LED_GPIO_OFF = 1, }; + #endif +enum color_led_gpio_state { + COLOR_LED_OFF = 0, + COLOR_LED_ON = 1, +}; + #define LED_BLINK_TIME 50 enum led_animation_mode_list { diff --git a/apps/esp8266/st_lamp/main/smart_lamp.c b/apps/esp8266/st_lamp/main/smart_lamp.c index 27f156f8..a4789438 100755 --- a/apps/esp8266/st_lamp/main/smart_lamp.c +++ b/apps/esp8266/st_lamp/main/smart_lamp.c @@ -18,6 +18,7 @@ #include #include +#include #include "st_dev.h" #include "device_control.h" @@ -26,6 +27,10 @@ #include "freertos/task.h" #include "driver/gpio.h" +#include "caps_switch.h" +#include "caps_switchLevel.h" +#include "caps_colorControl.h" + // onboarding_config_start is null-terminated string extern const uint8_t onboarding_config_start[] asm("_binary_onboarding_config_json_start"); extern const uint8_t onboarding_config_end[] asm("_binary_onboarding_config_json_end"); @@ -34,21 +39,22 @@ extern const uint8_t onboarding_config_end[] asm("_binary_onboarding_config_json extern const uint8_t device_info_start[] asm("_binary_device_info_json_start"); extern const uint8_t device_info_end[] asm("_binary_device_info_json_end"); -enum smartlamp_switch_onoff_state { - SMARTLAMP_SWITCH_OFF = 0, - SMARTLAMP_SWITCH_ON = 1, +enum switch_onoff_state { + SWITCH_OFF = 0, + SWITCH_ON = 1, }; -static int smartlamp_switch_state = SMARTLAMP_SWITCH_ON; -static double smartlamp_color_hue = 0; -static double smartlamp_color_saturation = 100; -static int smartlamp_color_level = 50; -static int smartlamp_color_red = 255; -static int smartlamp_color_green = 255; -static int smartlamp_color_blue = 255; -static int smartlamp_brightness_level = 100; +static caps_switch_data_t *cap_switch_data; +static caps_switchLevel_data_t *cap_switchLevel_data; +static caps_colorControl_data_t *cap_colorControl_data; + +static int hsl_color_lightness = 50; +static int rgb_color_red = 255; +static int rgb_color_green = 255; +static int rgb_color_blue = 255; static iot_status_t g_iot_status; +static iot_stat_lv_t g_iot_stat_lv; static int noti_led_mode = LED_ANIMATION_MODE_IDLE; @@ -56,93 +62,111 @@ IOT_CTX* ctx = NULL; //#define SET_PIN_NUMBER_CONFRIM -/* Send integer type capability to SmartThings Sever */ -static void send_capability_integer(IOT_CAP_HANDLE *handle, char* attribute_name, int value) +static int get_switch_state(void) { - IOT_EVENT *cap_evt; - uint8_t evt_num = 1; - int32_t sequence_no; + const char* switch_value = cap_switch_data->get_switch_value(cap_switch_data); + int switch_state = SWITCH_OFF; + if(!strcmp(switch_value, caps_helper_switch.attr_switch.values[CAPS_HELPER_SWITCH_VALUE_ON])) { + switch_state = SWITCH_ON; + } else if(!strcmp(switch_value, caps_helper_switch.attr_switch.values[CAPS_HELPER_SWITCH_VALUE_OFF])) { + switch_state = SWITCH_OFF; + } + return switch_state; +} - cap_evt = st_cap_attr_create_int(attribute_name, value, NULL); +static void noti_led_onoff(int onoff) +{ + if (onoff == SWITCH_OFF) { + gpio_set_level(GPIO_OUTPUT_NOTIFICATION_LED, NOTIFICATION_LED_GPIO_OFF); + } else { + gpio_set_level(GPIO_OUTPUT_NOTIFICATION_LED, NOTIFICATION_LED_GPIO_ON); + } +} - sequence_no = st_cap_attr_send(handle, evt_num, &cap_evt); - if (sequence_no < 0) - printf("fail to send data\n"); +static void color_led_onoff(int onoff) +{ + if (onoff == SWITCH_OFF) { + gpio_set_level(GPIO_OUTPUT_COLORLED_R, COLOR_LED_OFF); + gpio_set_level(GPIO_OUTPUT_COLORLED_G, COLOR_LED_OFF); + gpio_set_level(GPIO_OUTPUT_COLORLED_B, COLOR_LED_OFF); + } else { + gpio_set_level(GPIO_OUTPUT_COLORLED_R, (rgb_color_red > 127) ? COLOR_LED_ON : COLOR_LED_OFF); + gpio_set_level(GPIO_OUTPUT_COLORLED_G, (rgb_color_green > 127) ? COLOR_LED_ON : COLOR_LED_OFF); + gpio_set_level(GPIO_OUTPUT_COLORLED_B, (rgb_color_blue > 127) ? COLOR_LED_ON : COLOR_LED_OFF); + } +} - printf("Sequence number return : %d\n", sequence_no); - st_cap_attr_free(cap_evt); +static void change_switch_state(int state) +{ + noti_led_onoff(state); + color_led_onoff(state); } -static void send_color_capability(IOT_CAP_HANDLE *handle, double hue, double saturation) +static void change_switch_level(int level) { - IOT_EVENT *cap_evt[2]; - uint8_t evt_num = 2; - int32_t sequence_no; + /* + * YOUR CODE: + * implement a ability to set switch level + */ + printf("switch level is changed to %d", level); + return; +} - cap_evt[0] = st_cap_attr_create_number("hue", hue, NULL); - cap_evt[1] = st_cap_attr_create_number("saturation", saturation, NULL); +static void update_color_info(void) +{ + int switch_state; + double hue = cap_colorControl_data->get_hue_value(cap_colorControl_data); + double saturation = cap_colorControl_data->get_saturation_value(cap_colorControl_data); - sequence_no = st_cap_attr_send(handle, evt_num, cap_evt); - if (sequence_no < 0) - printf("fail to send data\n"); + update_rgb_from_hsl(hue, saturation, hsl_color_lightness, + &rgb_color_red, &rgb_color_green, &rgb_color_blue); - printf("Sequence number return : %d\n", sequence_no); - st_cap_attr_free(cap_evt[0]); - st_cap_attr_free(cap_evt[1]); + printf("HSL (%lf, %lf, %d), RGB (%d, %d, %d)\n", + hue, saturation, hsl_color_lightness, + rgb_color_red, rgb_color_green, rgb_color_blue); + switch_state = get_switch_state(); + color_led_onoff(switch_state); } - -static void color_led_onoff(int32_t state) +void cap_switch_init_cb(struct caps_switch_data *caps_data) { - if (state == 0) { - gpio_set_level(GPIO_OUTPUT_COLORLED_R, 0); - gpio_set_level(GPIO_OUTPUT_COLORLED_G, 0); - gpio_set_level(GPIO_OUTPUT_COLORLED_B, 0); - } else { - gpio_set_level(GPIO_OUTPUT_COLORLED_R, (smartlamp_color_red > 127)); - gpio_set_level(GPIO_OUTPUT_COLORLED_G, (smartlamp_color_green > 127)); - gpio_set_level(GPIO_OUTPUT_COLORLED_B, (smartlamp_color_blue > 127)); - } + int switch_init_state = CAPS_HELPER_SWITCH_VALUE_OFF; + caps_data->set_switch_value(caps_data, caps_helper_switch.attr_switch.values[switch_init_state]); } -static void change_switch_state(int32_t state) +void cap_colorControl_init_cb(struct caps_colorControl_data *caps_data) { - /* change state */ - smartlamp_switch_state = state; - color_led_onoff(smartlamp_switch_state); - if(state == SMARTLAMP_SWITCH_ON) { - gpio_set_level(GPIO_OUTPUT_NOTIFICATION_LED, NOTIFICATION_LED_GPIO_ON); - color_led_onoff(1); - } else { - gpio_set_level(GPIO_OUTPUT_NOTIFICATION_LED, NOTIFICATION_LED_GPIO_OFF); - color_led_onoff(0); - } + int hue_init_value = 0; + int saturation_init_value = 100; + caps_data->set_color_value(caps_data, hue_init_value, saturation_init_value); } -static void send_switch_cap_evt(IOT_CAP_HANDLE *handle, int32_t state) +void cap_switchLevel_init_cb(struct caps_switchLevel_data *caps_data) { - IOT_EVENT *switch_evt; - uint8_t evt_num = 1; - int32_t sequence_no; + int switch_init_level = 50; + caps_data->set_level_value(caps_data, switch_init_level); + caps_data->set_level_unit(caps_data, caps_helper_switchLevel.attr_level.units[CAPS_HELPER_SWITCH_LEVEL_UNIT_PERCENT]); +} - /* Setup switch onoff state */ - if(state == SMARTLAMP_SWITCH_ON) { - switch_evt = st_cap_attr_create_string("switch", "on", NULL); - } else { - switch_evt = st_cap_attr_create_string("switch", "off", NULL); - } +void cap_switch_cmd_cb(struct caps_switch_data *caps_data) +{ + int switch_state = get_switch_state(); + change_switch_state(switch_state); +} - /* Send switch onoff event */ - sequence_no = st_cap_attr_send(handle, evt_num, &switch_evt); - if (sequence_no < 0) - printf("fail to send switch onoff data\n"); +void cap_switchLevel_cmd_cb(struct caps_switchLevel_data *caps_data) +{ + int switch_level = caps_data->get_level_value(caps_data); + change_switch_level(switch_level); +} - printf("Sequence number return : %d\n", sequence_no); - st_cap_attr_free(switch_evt); +void cap_colorControl_cmd_cb(struct caps_colorControl_data *caps_data) +{ + update_color_info(); } -static void button_event(IOT_CAP_HANDLE *handle, uint32_t type, uint32_t count) +static void button_event(IOT_CAP_HANDLE *handle, int type, int count) { if (type == BUTTON_SHORT_PRESS) { printf("Button short press, count: %d\n", count); @@ -150,16 +174,17 @@ static void button_event(IOT_CAP_HANDLE *handle, uint32_t type, uint32_t count) case 1: if (g_iot_status == IOT_STATUS_NEED_INTERACT) { st_conn_ownership_confirm(ctx, true); - gpio_set_level(GPIO_OUTPUT_NOTIFICATION_LED, NOTIFICATION_LED_GPIO_OFF); + noti_led_onoff(SWITCH_OFF); noti_led_mode = LED_ANIMATION_MODE_IDLE; } else { - /* change switch state and LED state */ - if (smartlamp_switch_state == SMARTLAMP_SWITCH_ON) { - change_switch_state(SMARTLAMP_SWITCH_OFF); - send_switch_cap_evt(handle, SMARTLAMP_SWITCH_OFF); + if (get_switch_state() == SWITCH_ON) { + change_switch_state(SWITCH_OFF); + cap_switch_data->set_switch_value(cap_switch_data, caps_helper_switch.attr_switch.values[CAPS_HELPER_SWITCH_VALUE_OFF]); + cap_switch_data->attr_switch_send(cap_switch_data); } else { - change_switch_state(SMARTLAMP_SWITCH_ON); - send_switch_cap_evt(handle, SMARTLAMP_SWITCH_ON); + change_switch_state(SWITCH_ON); + cap_switch_data->set_switch_value(cap_switch_data, caps_helper_switch.attr_switch.values[CAPS_HELPER_SWITCH_VALUE_ON]); + cap_switch_data->attr_switch_send(cap_switch_data); } } break; @@ -180,7 +205,9 @@ static void iot_status_cb(iot_status_t status, iot_stat_lv_t stat_lv, void *usr_data) { g_iot_status = status; - printf("iot_status: %d, lv: %d\n", status, stat_lv); + g_iot_stat_lv = stat_lv; + + printf("status: %d, stat: %d\n", g_iot_status, g_iot_stat_lv); switch(status) { @@ -190,153 +217,13 @@ static void iot_status_cb(iot_status_t status, case IOT_STATUS_IDLE: case IOT_STATUS_CONNECTING: noti_led_mode = LED_ANIMATION_MODE_IDLE; - if (smartlamp_switch_state == SMARTLAMP_SWITCH_ON) { - gpio_set_level(GPIO_OUTPUT_NOTIFICATION_LED, NOTIFICATION_LED_GPIO_ON); - } else { - gpio_set_level(GPIO_OUTPUT_NOTIFICATION_LED, NOTIFICATION_LED_GPIO_OFF); - } + noti_led_onoff(get_switch_state()); break; default: break; } } - -#include "driver/hw_timer.h" -#define PWM_LEVEL 10 -uint32_t ulHighFrequencyTimerTicks; -void hw_timer_callback(void *arg) -{ - ulHighFrequencyTimerTicks++; - - color_led_onoff((ulHighFrequencyTimerTicks% (PWM_LEVEL + 1)) - < (smartlamp_switch_state * PWM_LEVEL * smartlamp_brightness_level/100)); -} - -void cap_color_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) -{ - send_color_capability(handle, smartlamp_color_hue, smartlamp_color_saturation); -} - -void cap_color_cmd_cb(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) -{ - int tmp_state; - printf("called [%s] func with : num_args:%u\n", - __func__, cmd_data->num_args); - - smartlamp_color_saturation = cmd_data->cmd_data[0].number; - smartlamp_color_hue = cmd_data->cmd_data[1].number; - - update_rgb_from_hsl(smartlamp_color_hue, smartlamp_color_saturation, smartlamp_color_level, - &smartlamp_color_red, &smartlamp_color_green, &smartlamp_color_blue); - - printf("HSL (%lf, %lf, %d), RGB (%d, %d, %d)\n", - smartlamp_color_hue, smartlamp_color_saturation, smartlamp_color_level, - smartlamp_color_red, smartlamp_color_green, smartlamp_color_blue); - - tmp_state = smartlamp_switch_state; - smartlamp_switch_state = SMARTLAMP_SWITCH_ON; - - - send_color_capability(handle, smartlamp_color_hue, smartlamp_color_saturation); - - vTaskDelay(LED_BLINK_TIME / portTICK_PERIOD_MS); - smartlamp_switch_state = tmp_state; -} - -void cap_level_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) -{ - send_capability_integer(handle, "level", smartlamp_brightness_level); -} - -void level_cmd_cb(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) -{ - int tmp_state; - - printf("called [%s] func with : num_args:%u\n", - __func__, cmd_data->num_args); - smartlamp_brightness_level = cmd_data->cmd_data[0].integer; - - tmp_state = smartlamp_switch_state; - smartlamp_switch_state = SMARTLAMP_SWITCH_ON; - - send_capability_integer(handle, "level", smartlamp_brightness_level); - - vTaskDelay(LED_BLINK_TIME / portTICK_PERIOD_MS); - smartlamp_switch_state = tmp_state; -} - -void cap_switch_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) -{ - IOT_EVENT *init_evt; - uint8_t evt_num = 1; - int32_t sequence_no; - - /* Setup switch on state */ - init_evt = st_cap_attr_create_string("switch", "on", NULL); - - /* Send switch on event */ - sequence_no = st_cap_attr_send(handle, evt_num, &init_evt); - if (sequence_no < 0) - printf("fail to send init_data\n"); - - printf("Sequence number return : %d\n", sequence_no); - st_cap_attr_free(init_evt); -} - - - -void cap_switch_cmd_off_cb(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) -{ - IOT_EVENT *off_evt; - uint8_t evt_num = 1; - int32_t sequence_no; - - printf("called [%s] func with : num_args:%u\n", - __func__, cmd_data->num_args); - - change_switch_state(SMARTLAMP_SWITCH_OFF); - - /* Setup switch off state */ - off_evt = st_cap_attr_create_string("switch", "off", NULL); - - /* Send switch off event */ - sequence_no = st_cap_attr_send(handle, evt_num, &off_evt); - if (sequence_no < 0) - printf("fail to send off_data\n"); - - printf("Sequence number return : %d\n", sequence_no); - st_cap_attr_free(off_evt); -} - - -void cap_switch_cmd_on_cb(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) -{ - IOT_EVENT *on_evt; - uint8_t evt_num = 1; - int32_t sequence_no; - - printf("called [%s] func with : num_args:%u\n", - __func__, cmd_data->num_args); - - change_switch_state(SMARTLAMP_SWITCH_ON); - - /* Setup switch on state */ - on_evt = st_cap_attr_create_string("switch", "on", NULL); - - /* Send switch on event */ - sequence_no = st_cap_attr_send(handle, evt_num, &on_evt); - if (sequence_no < 0) - printf("fail to send on_data\n"); - - printf("Sequence number return : %d\n", sequence_no); - st_cap_attr_free(on_evt); -} - void iot_noti_cb(iot_noti_data_t *noti_data, void *noti_usr_data) { printf("Notification message received\n"); @@ -407,13 +294,8 @@ void app_main(void) unsigned int onboarding_config_len = onboarding_config_end - onboarding_config_start; unsigned char *device_info = (unsigned char *) device_info_start; unsigned int device_info_len = device_info_end - device_info_start; - IOT_CAP_HANDLE* switch_handle = NULL; - IOT_CAP_HANDLE* color_handle = NULL; - IOT_CAP_HANDLE* level_handle = NULL; - int iot_err; - hw_timer_init(hw_timer_callback, NULL); - hw_timer_alarm_us(1000, true); + int iot_err; // 1. create a iot context ctx = st_conn_init(onboarding_config, onboarding_config_len, device_info, device_info_len); @@ -424,41 +306,26 @@ void app_main(void) // 2. create a handle to process capability // implement init_callback function - switch_handle = st_cap_handle_init(ctx, "main", "switch", cap_switch_init_cb, NULL); - color_handle = st_cap_handle_init(ctx, "main", "colorControl", cap_color_init_cb, NULL); - level_handle = st_cap_handle_init(ctx, "main", "switchLevel", cap_level_init_cb, NULL); + cap_switch_data = caps_switch_initialize(ctx, "main", cap_switch_init_cb, NULL); + cap_switchLevel_data = caps_switchLevel_initialize(ctx, "main", cap_switchLevel_init_cb, NULL); + cap_colorControl_data = caps_colorControl_initialize(ctx, "main", cap_colorControl_init_cb, NULL); // 3. register a callback function to process capability command when it comes from the SmartThings Server // implement callback function - iot_err = st_cap_cmd_set_cb(switch_handle, "off", cap_switch_cmd_off_cb, NULL); - if (iot_err) - printf("fail to set cmd_cb for off\n"); - iot_err = st_cap_cmd_set_cb(switch_handle, "on", cap_switch_cmd_on_cb, NULL); - if (iot_err) - printf("fail to set cmd_cb for on\n"); - iot_err = st_cap_cmd_set_cb(color_handle, "setColor", cap_color_cmd_cb, NULL); - if (iot_err) - printf("fail to set cmd_cb for setcolor\n"); - iot_err = st_cap_cmd_set_cb(level_handle, "setLevel", level_cmd_cb, NULL); - if (iot_err) - printf("fail to set cmd_cb for setcolor\n"); - + cap_switch_data->cmd_on_usr_cb = cap_switch_cmd_cb; + cap_switch_data->cmd_off_usr_cb = cap_switch_cmd_cb; + cap_switchLevel_data->cmd_set_level_usr_cb = cap_switchLevel_cmd_cb; + cap_colorControl_data->cmd_setColor_usr_cb = cap_colorControl_cmd_cb; } else { printf("fail to create the iot_context\n"); } gpio_init(); - update_rgb_from_hsl(smartlamp_color_hue, smartlamp_color_saturation, smartlamp_color_level, - &smartlamp_color_red, &smartlamp_color_green, &smartlamp_color_blue); - - printf("HSL (%lf, %lf, %d), RGB (%d, %d, %d)\n", - smartlamp_color_hue, smartlamp_color_saturation, smartlamp_color_level, - smartlamp_color_red, smartlamp_color_green, smartlamp_color_blue); - color_led_onoff(smartlamp_switch_state); + update_color_info(); // 4. needed when it is necessary to keep monitoring the device status - xTaskCreate(smartlamp_task, "smartlamp_task", 2048, (void *)switch_handle, 10, NULL); + xTaskCreate(smartlamp_task, "smartlamp_task", 2048, NULL, 10, NULL); #if defined(SET_PIN_NUMBER_CONFRIM) iot_pin_t *pin_num; diff --git a/apps/esp8266/st_lamp/sdkconfig b/apps/esp8266/st_lamp/sdkconfig index 90b6c318..bc5f8bdd 100644 --- a/apps/esp8266/st_lamp/sdkconfig +++ b/apps/esp8266/st_lamp/sdkconfig @@ -390,7 +390,6 @@ CONFIG_STDK_IOT_CORE_LOG_LEVEL_ERROR=y CONFIG_STDK_IOT_CORE_LOG_LEVEL_WARN=y CONFIG_STDK_IOT_CORE_LOG_LEVEL_INFO=y CONFIG_STDK_IOT_CORE_LOG_LEVEL_DEBUG= -CONFIG_STDK_IOT_CORE_PROFILE_PING= CONFIG_STDK_IOT_CORE_SUPPORT_STNV_PARTITION= CONFIG_STDK_IOT_CORE_BSP_SUPPORT_ESP8266=y CONFIG_STDK_IOT_CORE_BSP_SUPPORT_ESP32= diff --git a/apps/esp8266/st_switch/main/caps_switch.c b/apps/esp8266/st_switch/main/caps_switch.c new file mode 100644 index 00000000..f419e1fa --- /dev/null +++ b/apps/esp8266/st_switch/main/caps_switch.c @@ -0,0 +1,134 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include + +#include "st_dev.h" +#include "caps_switch.h" + +#include "freertos/FreeRTOS.h" + +static const char *caps_switch_get_switch_value(caps_switch_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->switch_value; +} + +static void caps_switch_set_switch_value(caps_switch_data_t *caps_data, const char *value) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->switch_value = (char *)value; +} + +static void caps_switch_attr_switch_send(caps_switch_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int sequence_no; + + cap_evt = st_cap_attr_create_string((char *)caps_helper_switch.attr_switch.name, + caps_data->switch_value, NULL); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send switch value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + + +static void caps_switch_cmd_off_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_switch_data_t *caps_data = (caps_switch_data_t *)usr_data; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_switch_set_switch_value(caps_data, caps_helper_switch.attr_switch.values[CAPS_HELPER_SWITCH_VALUE_OFF]); + if (caps_data && caps_data->cmd_off_usr_cb) + caps_data->cmd_off_usr_cb(caps_data); + caps_switch_attr_switch_send(caps_data); +} + + +static void caps_switch_cmd_on_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_switch_data_t *caps_data = (caps_switch_data_t *)usr_data; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_switch_set_switch_value(caps_data, caps_helper_switch.attr_switch.values[CAPS_HELPER_SWITCH_VALUE_ON]); + if (caps_data && caps_data->cmd_off_usr_cb) + caps_data->cmd_off_usr_cb(caps_data); + caps_switch_attr_switch_send(caps_data); +} + +static void caps_switch_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) +{ + caps_switch_data_t *caps_data = usr_data; + if (caps_data && caps_data->init_usr_cb) + caps_data->init_usr_cb(caps_data); + caps_switch_attr_switch_send(caps_data); +} + +caps_switch_data_t *caps_switch_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data) +{ + caps_switch_data_t *caps_data = NULL; + int err; + + caps_data = malloc(sizeof(caps_switch_data_t)); + if (!caps_data) { + printf("fail to malloc for caps_switch_data\n"); + return NULL; + } + + memset(caps_data, 0, sizeof(caps_switch_data_t)); + + caps_data->handle = st_cap_handle_init(ctx, component, caps_helper_switch.id , caps_switch_init_cb, caps_data); + caps_data->init_usr_cb = init_usr_cb; + caps_data->usr_data = usr_data; + + caps_data->get_switch_value = caps_switch_get_switch_value; + caps_data->set_switch_value = caps_switch_set_switch_value; + caps_data->attr_switch_send = caps_switch_attr_switch_send; + + caps_data->switch_value = (char *)caps_helper_switch.attr_switch.values[CAPS_HELPER_SWITCH_VALUE_ON]; + + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_switch.cmd_off.name, caps_switch_cmd_off_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for off\n"); + return NULL; + } + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_switch.cmd_on.name, caps_switch_cmd_on_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for on\n"); + return NULL; + } + + return caps_data; +} diff --git a/apps/esp8266/st_switch/main/caps_switch.h b/apps/esp8266/st_switch/main/caps_switch.h new file mode 100644 index 00000000..89e7488c --- /dev/null +++ b/apps/esp8266/st_switch/main/caps_switch.h @@ -0,0 +1,36 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include "caps/iot_caps_helper_switch.h" + +typedef struct caps_switch_data { + IOT_CAP_HANDLE* handle; + void *usr_data; + + char *switch_value; + const char *(*get_switch_value)(struct caps_switch_data *caps_data); + void (*set_switch_value)(struct caps_switch_data *caps_data, const char *value); + void (*attr_switch_send)(struct caps_switch_data *caps_data); + + void (*init_usr_cb)(struct caps_switch_data *caps_data); + + void (*cmd_on_usr_cb)(struct caps_switch_data *caps_data); + void (*cmd_off_usr_cb)(struct caps_switch_data *caps_data); +} caps_switch_data_t; + +caps_switch_data_t *caps_switch_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data); diff --git a/apps/esp8266/st_switch/main/device_control.h b/apps/esp8266/st_switch/main/device_control.h index 7204bc8e..01f12737 100644 --- a/apps/esp8266/st_switch/main/device_control.h +++ b/apps/esp8266/st_switch/main/device_control.h @@ -68,8 +68,6 @@ enum notification_led_gpio_state { #endif - - enum main_led_gpio_state { MAINLED_GPIO_ON = 1, MAINLED_GPIO_OFF = 0, diff --git a/apps/esp8266/st_switch/main/smart_switch.c b/apps/esp8266/st_switch/main/smart_switch.c index 93a23e1e..b77ea803 100755 --- a/apps/esp8266/st_switch/main/smart_switch.c +++ b/apps/esp8266/st_switch/main/smart_switch.c @@ -18,6 +18,7 @@ //for implementing main features of IoT device #include +#include #include "st_dev.h" #include "device_control.h" @@ -26,6 +27,8 @@ #include "freertos/task.h" #include "driver/gpio.h" +#include "caps_switch.h" + // onboarding_config_start is null-terminated string extern const uint8_t onboarding_config_start[] asm("_binary_onboarding_config_json_start"); extern const uint8_t onboarding_config_end[] asm("_binary_onboarding_config_json_end"); @@ -34,56 +37,69 @@ extern const uint8_t onboarding_config_end[] asm("_binary_onboarding_config_json extern const uint8_t device_info_start[] asm("_binary_device_info_json_start"); extern const uint8_t device_info_end[] asm("_binary_device_info_json_end"); -enum smartswitch_switch_onoff_state { - SMARTSWITCH_SWITCH_OFF = 0, - SMARTSWITCH_SWITCH_ON = 1, +enum switch_onoff_state { + SWITCH_OFF = 0, + SWITCH_ON = 1, }; -static int32_t smartswitch_switch_state = SMARTSWITCH_SWITCH_ON; +static caps_switch_data_t *cap_switch_data; static iot_status_t g_iot_status; +static iot_stat_lv_t g_iot_stat_lv; static int noti_led_mode = LED_ANIMATION_MODE_IDLE; IOT_CTX *ctx = NULL; +static int get_switch_state(void) +{ + const char* switch_value = cap_switch_data->get_switch_value(cap_switch_data); + int switch_state = SWITCH_OFF; + if(!strcmp(switch_value, caps_helper_switch.attr_switch.values[CAPS_HELPER_SWITCH_VALUE_ON])) { + switch_state = SWITCH_ON; + } else if(!strcmp(switch_value, caps_helper_switch.attr_switch.values[CAPS_HELPER_SWITCH_VALUE_OFF])) { + switch_state = SWITCH_OFF; + } + return switch_state; +} -static void change_switch_state(int32_t state) +static void noti_led_onoff(int onoff) { - /* change state */ - smartswitch_switch_state = state; - if(state == SMARTSWITCH_SWITCH_ON) { - gpio_set_level(GPIO_OUTPUT_MAINLED, MAINLED_GPIO_ON); - gpio_set_level(GPIO_OUTPUT_NOTIFICATION_LED, NOTIFICATION_LED_GPIO_ON); - } else { - gpio_set_level(GPIO_OUTPUT_MAINLED, MAINLED_GPIO_OFF); + if (onoff == SWITCH_OFF) { gpio_set_level(GPIO_OUTPUT_NOTIFICATION_LED, NOTIFICATION_LED_GPIO_OFF); + } else { + gpio_set_level(GPIO_OUTPUT_NOTIFICATION_LED, NOTIFICATION_LED_GPIO_ON); } } -static void send_switch_cap_evt(IOT_CAP_HANDLE *handle, int32_t state) +static void main_led_onoff(int onoff) { - IOT_EVENT *switch_evt; - uint8_t evt_num = 1; - int32_t sequence_no; - - /* Setup switch onoff state */ - if(state == SMARTSWITCH_SWITCH_ON) { - switch_evt = st_cap_attr_create_string("switch", "on", NULL); + if (onoff == SWITCH_OFF) { + gpio_set_level(GPIO_OUTPUT_MAINLED, MAINLED_GPIO_OFF); } else { - switch_evt = st_cap_attr_create_string("switch", "off", NULL); + gpio_set_level(GPIO_OUTPUT_MAINLED, MAINLED_GPIO_ON); } +} + +static void change_switch_state(int state) +{ + noti_led_onoff(state); + main_led_onoff(state); +} - /* Send switch onoff event */ - sequence_no = st_cap_attr_send(handle, evt_num, &switch_evt); - if (sequence_no < 0) - printf("fail to send switch onoff data\n"); +void cap_switch_init_cb(struct caps_switch_data *caps_data) +{ + int switch_init_state = CAPS_HELPER_SWITCH_VALUE_OFF; + caps_data->set_switch_value(caps_data, caps_helper_switch.attr_switch.values[switch_init_state]); +} - printf("Sequence number return : %d\n", sequence_no); - st_cap_attr_free(switch_evt); +void cap_switch_cmd_cb(struct caps_switch_data *caps_data) +{ + int switch_state = get_switch_state(); + change_switch_state(switch_state); } -static void button_event(IOT_CAP_HANDLE *handle, uint32_t type, uint32_t count) +static void button_event(IOT_CAP_HANDLE *handle, int type, int count) { if (type == BUTTON_SHORT_PRESS) { printf("Button short press, count: %d\n", count); @@ -94,13 +110,14 @@ static void button_event(IOT_CAP_HANDLE *handle, uint32_t type, uint32_t count) gpio_set_level(GPIO_OUTPUT_NOTIFICATION_LED, NOTIFICATION_LED_GPIO_OFF); noti_led_mode = LED_ANIMATION_MODE_IDLE; } else { - /* change switch state and LED state */ - if (smartswitch_switch_state == SMARTSWITCH_SWITCH_ON) { - change_switch_state(SMARTSWITCH_SWITCH_OFF); - send_switch_cap_evt(handle, SMARTSWITCH_SWITCH_OFF); + if (get_switch_state() == SWITCH_ON) { + change_switch_state(SWITCH_OFF); + cap_switch_data->set_switch_value(cap_switch_data, caps_helper_switch.attr_switch.values[CAPS_HELPER_SWITCH_VALUE_OFF]); + cap_switch_data->attr_switch_send(cap_switch_data); } else { - change_switch_state(SMARTSWITCH_SWITCH_ON); - send_switch_cap_evt(handle, SMARTSWITCH_SWITCH_ON); + change_switch_state(SWITCH_ON); + cap_switch_data->set_switch_value(cap_switch_data, caps_helper_switch.attr_switch.values[CAPS_HELPER_SWITCH_VALUE_ON]); + cap_switch_data->attr_switch_send(cap_switch_data); } } break; @@ -121,7 +138,9 @@ static void iot_status_cb(iot_status_t status, iot_stat_lv_t stat_lv, void *usr_data) { g_iot_status = status; - printf("iot_status: %d, lv: %d\n", status, stat_lv); + g_iot_stat_lv = stat_lv; + + printf("status: %d, stat: %d\n", g_iot_status, g_iot_stat_lv); switch(status) { @@ -131,85 +150,13 @@ static void iot_status_cb(iot_status_t status, case IOT_STATUS_IDLE: case IOT_STATUS_CONNECTING: noti_led_mode = LED_ANIMATION_MODE_IDLE; - if (smartswitch_switch_state == SMARTSWITCH_SWITCH_ON) { - gpio_set_level(GPIO_OUTPUT_NOTIFICATION_LED, NOTIFICATION_LED_GPIO_ON); - } else { - gpio_set_level(GPIO_OUTPUT_NOTIFICATION_LED, NOTIFICATION_LED_GPIO_OFF); - } + noti_led_onoff(get_switch_state()); break; default: break; } } - -void cap_switch_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) -{ - IOT_EVENT *init_evt; - uint8_t evt_num = 1; - int32_t sequence_no; - - /* Setup switch on state */ - init_evt = st_cap_attr_create_string("switch", "on", NULL); - - /* Send switch on event */ - sequence_no = st_cap_attr_send(handle, evt_num, &init_evt); - if (sequence_no < 0) - printf("fail to send init_data\n"); - - printf("Sequence number return : %d\n", sequence_no); - st_cap_attr_free(init_evt); -} - -void cap_switch_cmd_off_cb(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) -{ - IOT_EVENT *off_evt; - uint8_t evt_num = 1; - int32_t sequence_no; - - printf("called [%s] func with : num_args:%u\n", - __func__, cmd_data->num_args); - - change_switch_state(SMARTSWITCH_SWITCH_OFF); - - /* Setup switch off state */ - off_evt = st_cap_attr_create_string("switch", "off", NULL); - - /* Send switch off event */ - sequence_no = st_cap_attr_send(handle, evt_num, &off_evt); - if (sequence_no < 0) - printf("fail to send off_data\n"); - - printf("Sequence number return : %d\n", sequence_no); - st_cap_attr_free(off_evt); -} - - -void cap_switch_cmd_on_cb(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) -{ - IOT_EVENT *on_evt; - uint8_t evt_num = 1; - int32_t sequence_no; - - printf("called [%s] func with : num_args:%u\n", - __func__, cmd_data->num_args); - - change_switch_state(SMARTSWITCH_SWITCH_ON); - - /* Setup switch on state */ - on_evt = st_cap_attr_create_string("switch", "on", NULL); - - /* Send switch on event */ - sequence_no = st_cap_attr_send(handle, evt_num, &on_evt); - if (sequence_no < 0) - printf("fail to send on_data\n"); - - printf("Sequence number return : %d\n", sequence_no); - st_cap_attr_free(on_evt); -} - void iot_noti_cb(iot_noti_data_t *noti_data, void *noti_usr_data) { printf("Notification message received\n"); @@ -283,19 +230,12 @@ void app_main(void) // 2. create a handle to process capability // implement init_callback function (cap_switch_init_cb) - handle = st_cap_handle_init(ctx, "main", "switch", cap_switch_init_cb, NULL); + cap_switch_data = caps_switch_initialize(ctx, "main", cap_switch_init_cb, NULL); // 3. register a callback function to process capability command when it comes from the SmartThings Server // implement callback function (cap_switch_cmd_off_cb) - iot_err = st_cap_cmd_set_cb(handle, "off", cap_switch_cmd_off_cb, NULL); - if (iot_err) - printf("fail to set cmd_cb for off\n"); - - // implement callback function (cap_switch_cmd_on_cb) - iot_err = st_cap_cmd_set_cb(handle, "on", cap_switch_cmd_on_cb, NULL); - if (iot_err) - printf("fail to set cmd_cb for on\n"); - + cap_switch_data->cmd_on_usr_cb = cap_switch_cmd_cb; + cap_switch_data->cmd_off_usr_cb = cap_switch_cmd_cb; } else { printf("fail to create the iot_context\n"); } diff --git a/apps/esp8266/st_switch/sdkconfig b/apps/esp8266/st_switch/sdkconfig index 49a6b39c..bc5f8bdd 100644 --- a/apps/esp8266/st_switch/sdkconfig +++ b/apps/esp8266/st_switch/sdkconfig @@ -390,13 +390,10 @@ CONFIG_STDK_IOT_CORE_LOG_LEVEL_ERROR=y CONFIG_STDK_IOT_CORE_LOG_LEVEL_WARN=y CONFIG_STDK_IOT_CORE_LOG_LEVEL_INFO=y CONFIG_STDK_IOT_CORE_LOG_LEVEL_DEBUG= -CONFIG_STDK_IOT_CORE_PROFILE_PING= CONFIG_STDK_IOT_CORE_SUPPORT_STNV_PARTITION= CONFIG_STDK_IOT_CORE_BSP_SUPPORT_ESP8266=y CONFIG_STDK_IOT_CORE_BSP_SUPPORT_ESP32= CONFIG_STDK_IOT_CORE_OS_SUPPORT_FREERTOS=y -CONFIG_STDK_IOT_CORE_OS_SUPPORT_TIZENRT= -CONFIG_STDK_IOT_CORE_OS_SUPPORT_POSIX= CONFIG_STDK_DEBUG_MEMORY_CHECK= # diff --git a/apps/esp8266/st_thermostat/main/caps_temperatureMeasurement.c b/apps/esp8266/st_thermostat/main/caps_temperatureMeasurement.c new file mode 100644 index 00000000..fe6597c9 --- /dev/null +++ b/apps/esp8266/st_thermostat/main/caps_temperatureMeasurement.c @@ -0,0 +1,112 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include + +#include "st_dev.h" +#include "caps_temperatureMeasurement.h" + +#include "freertos/FreeRTOS.h" + +static int caps_temperatureMeasurement_get_temperature_value(caps_temperatureMeasurement_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->temperature_value; +} + +static void caps_temperatureMeasurement_set_temperature_value(caps_temperatureMeasurement_data_t *caps_data, int value) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->temperature_value = value; +} + +static const char *caps_temperatureMeasurement_get_temperature_unit(caps_temperatureMeasurement_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->temperature_unit; +} + +static void caps_temperatureMeasurement_set_temperature_unit(caps_temperatureMeasurement_data_t *caps_data, const char *unit) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->temperature_unit = (char *)unit; +} + +static void caps_temperatureMeasurement_attr_temperature_send(caps_temperatureMeasurement_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int sequence_no; + + cap_evt = st_cap_attr_create_int((char *) caps_helper_temperatureMeasurement.attr_temperature.name, caps_data->temperature_value, caps_data->temperature_unit); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send temperature value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + +static void caps_temperatureMeasurement_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) +{ + caps_temperatureMeasurement_data_t *caps_data = usr_data; + if (caps_data && caps_data->init_usr_cb) + caps_data->init_usr_cb(caps_data); + caps_temperatureMeasurement_attr_temperature_send(caps_data); +} + +caps_temperatureMeasurement_data_t *caps_temperatureMeasurement_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data) +{ + caps_temperatureMeasurement_data_t *caps_data = NULL; + + caps_data = malloc(sizeof(caps_temperatureMeasurement_data_t)); + if (!caps_data) { + printf("fail to malloc for caps_temperatureMeasurement_data\n"); + return NULL; + } + + memset(caps_data, 0, sizeof(caps_temperatureMeasurement_data_t)); + + caps_data->handle = st_cap_handle_init(ctx, component, caps_helper_temperatureMeasurement.id , caps_temperatureMeasurement_init_cb, caps_data); + caps_data->init_usr_cb = init_usr_cb; + caps_data->usr_data = usr_data; + + caps_data->get_temperature_value = caps_temperatureMeasurement_get_temperature_value; + caps_data->set_temperature_value = caps_temperatureMeasurement_set_temperature_value; + caps_data->get_temperature_unit = caps_temperatureMeasurement_get_temperature_unit; + caps_data->set_temperature_unit = caps_temperatureMeasurement_set_temperature_unit; + caps_data->attr_temperature_send = caps_temperatureMeasurement_attr_temperature_send; + + caps_data->temperature_value = caps_helper_temperatureMeasurement.attr_temperature.min; + caps_data->temperature_unit = (char *)caps_helper_temperatureMeasurement.attr_temperature.units[CAPS_HELPER_TEMPERATURE_MEASUREMENT_UNIT_C]; + + return caps_data; +} diff --git a/apps/esp8266/st_thermostat/main/caps_temperatureMeasurement.h b/apps/esp8266/st_thermostat/main/caps_temperatureMeasurement.h new file mode 100644 index 00000000..da4b81fb --- /dev/null +++ b/apps/esp8266/st_thermostat/main/caps_temperatureMeasurement.h @@ -0,0 +1,36 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include "caps/iot_caps_helper_temperatureMeasurement.h" + +typedef struct caps_temperatureMeasurement_data { + IOT_CAP_HANDLE* handle; + void *usr_data; + + int temperature_value; + int (*get_temperature_value)(struct caps_temperatureMeasurement_data *caps_data); + void (*set_temperature_value)(struct caps_temperatureMeasurement_data *caps_data, int value); + char *temperature_unit; + const char *(*get_temperature_unit)(struct caps_temperatureMeasurement_data *caps_data); + void (*set_temperature_unit)(struct caps_temperatureMeasurement_data *caps_data, const char *unit); + void (*attr_temperature_send)(struct caps_temperatureMeasurement_data *caps_data); + + void (*init_usr_cb)(struct caps_temperatureMeasurement_data *caps_data); +} caps_temperatureMeasurement_data_t; + +caps_temperatureMeasurement_data_t *caps_temperatureMeasurement_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data); diff --git a/apps/esp8266/st_thermostat/main/caps_thermostatCoolingSetpoint.c b/apps/esp8266/st_thermostat/main/caps_thermostatCoolingSetpoint.c new file mode 100644 index 00000000..92d5fb79 --- /dev/null +++ b/apps/esp8266/st_thermostat/main/caps_thermostatCoolingSetpoint.c @@ -0,0 +1,136 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include + +#include "st_dev.h" +#include "caps_thermostatCoolingSetpoint.h" + +#include "freertos/FreeRTOS.h" + +static int caps_thermostatCoolingSetpoint_get_coolingSetpoint_value(caps_thermostatCoolingSetpoint_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->coolingSetpoint_value; +} + +static void caps_thermostatCoolingSetpoint_set_coolingSetpoint_value(caps_thermostatCoolingSetpoint_data_t *caps_data, int value) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->coolingSetpoint_value = value; +} + +static const char *caps_thermostatCoolingSetpoint_get_coolingSetpoint_unit(caps_thermostatCoolingSetpoint_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->coolingSetpoint_unit; +} + +static void caps_thermostatCoolingSetpoint_set_coolingSetpoint_unit(caps_thermostatCoolingSetpoint_data_t *caps_data, const char *unit) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->coolingSetpoint_unit = (char *)unit; +} + +static void caps_thermostatCoolingSetpoint_attr_coolingSetpoint_send(caps_thermostatCoolingSetpoint_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int sequence_no; + + cap_evt = st_cap_attr_create_int((char *) caps_helper_thermostatCoolingSetpoint.attr_coolingSetpoint.name, caps_data->coolingSetpoint_value, caps_data->coolingSetpoint_unit); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send coolingSetpoint value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + +static void caps_thermostatCoolingSetpoint_cmd_setCoolingSetpoint_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_thermostatCoolingSetpoint_data_t *caps_data = usr_data; + int value; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + value = cmd_data->cmd_data[0].number; + + caps_thermostatCoolingSetpoint_set_coolingSetpoint_value(caps_data, value); + if (caps_data && caps_data->cmd_setCoolingSetpoint_usr_cb) + caps_data->cmd_setCoolingSetpoint_usr_cb(caps_data); + caps_thermostatCoolingSetpoint_attr_coolingSetpoint_send(caps_data); +} + +static void caps_thermostatCoolingSetpoint_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) +{ + caps_thermostatCoolingSetpoint_data_t *caps_data = usr_data; + if (caps_data && caps_data->init_usr_cb) + caps_data->init_usr_cb(caps_data); + caps_thermostatCoolingSetpoint_attr_coolingSetpoint_send(caps_data); +} + +caps_thermostatCoolingSetpoint_data_t *caps_thermostatCoolingSetpoint_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data) +{ + caps_thermostatCoolingSetpoint_data_t *caps_data = NULL; + int err; + + caps_data = malloc(sizeof(caps_thermostatCoolingSetpoint_data_t)); + if (!caps_data) { + printf("fail to malloc for caps_thermostatCoolingSetpoint_data\n"); + return NULL; + } + + memset(caps_data, 0, sizeof(caps_thermostatCoolingSetpoint_data_t)); + + caps_data->handle = st_cap_handle_init(ctx, component, caps_helper_thermostatCoolingSetpoint.id , caps_thermostatCoolingSetpoint_init_cb, caps_data); + caps_data->init_usr_cb = init_usr_cb; + caps_data->usr_data = usr_data; + + caps_data->get_coolingSetpoint_value = caps_thermostatCoolingSetpoint_get_coolingSetpoint_value; + caps_data->set_coolingSetpoint_value = caps_thermostatCoolingSetpoint_set_coolingSetpoint_value; + caps_data->get_coolingSetpoint_unit = caps_thermostatCoolingSetpoint_get_coolingSetpoint_unit; + caps_data->set_coolingSetpoint_unit = caps_thermostatCoolingSetpoint_set_coolingSetpoint_unit; + caps_data->attr_coolingSetpoint_send = caps_thermostatCoolingSetpoint_attr_coolingSetpoint_send; + + caps_data->coolingSetpoint_value = caps_helper_thermostatCoolingSetpoint.attr_coolingSetpoint.min; + caps_data->coolingSetpoint_unit = (char *)caps_helper_thermostatCoolingSetpoint.attr_coolingSetpoint.units[CAPS_HELPER_THERMOSTAT_COOLING_SETPOINT_UNIT_C]; + + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_thermostatCoolingSetpoint.cmd_setCoolingSetpoint.name, caps_thermostatCoolingSetpoint_cmd_setCoolingSetpoint_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for set_coolingSetpoint\n"); + return NULL; + } + + return caps_data; +} diff --git a/apps/esp8266/st_thermostat/main/caps_thermostatCoolingSetpoint.h b/apps/esp8266/st_thermostat/main/caps_thermostatCoolingSetpoint.h new file mode 100644 index 00000000..06e581be --- /dev/null +++ b/apps/esp8266/st_thermostat/main/caps_thermostatCoolingSetpoint.h @@ -0,0 +1,38 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include "caps/iot_caps_helper_thermostatCoolingSetpoint.h" + +typedef struct caps_thermostatCoolingSetpoint_data { + IOT_CAP_HANDLE* handle; + void *usr_data; + + int coolingSetpoint_value; + int (*get_coolingSetpoint_value)(struct caps_thermostatCoolingSetpoint_data *caps_data); + void (*set_coolingSetpoint_value)(struct caps_thermostatCoolingSetpoint_data *caps_data, int value); + char *coolingSetpoint_unit; + const char *(*get_coolingSetpoint_unit)(struct caps_thermostatCoolingSetpoint_data *caps_data); + void (*set_coolingSetpoint_unit)(struct caps_thermostatCoolingSetpoint_data *caps_data, const char *unit); + void (*attr_coolingSetpoint_send)(struct caps_thermostatCoolingSetpoint_data *caps_data); + + void (*init_usr_cb)(struct caps_thermostatCoolingSetpoint_data *caps_data); + + void (*cmd_setCoolingSetpoint_usr_cb)(struct caps_thermostatCoolingSetpoint_data *caps_data); +} caps_thermostatCoolingSetpoint_data_t; + +caps_thermostatCoolingSetpoint_data_t *caps_thermostatCoolingSetpoint_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data); diff --git a/apps/esp8266/st_thermostat/main/caps_thermostatFanMode.c b/apps/esp8266/st_thermostat/main/caps_thermostatFanMode.c new file mode 100644 index 00000000..2f262d49 --- /dev/null +++ b/apps/esp8266/st_thermostat/main/caps_thermostatFanMode.c @@ -0,0 +1,237 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include + +#include "st_dev.h" +#include "caps_thermostatFanMode.h" + +#include "freertos/FreeRTOS.h" + +static const char *caps_thermostatFanMode_get_thermostatFanMode_value(caps_thermostatFanMode_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->thermostatFanMode_value; +} + +static void caps_thermostatFanMode_set_thermostatFanMode_value(caps_thermostatFanMode_data_t *caps_data, const char *value) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->thermostatFanMode_value = (char *)value; +} + + +static void caps_thermostatFanMode_attr_thermostatFanMode_send(caps_thermostatFanMode_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int sequence_no; + + cap_evt = st_cap_attr_create_string((char *)caps_helper_thermostatFanMode.attr_thermostatFanMode.name, + caps_data->thermostatFanMode_value, NULL); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send thermostatFanMode value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + +static const char **caps_thermostatFanMode_get_supportedThermostatFanModes_value(caps_thermostatFanMode_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return (const char **)caps_data->supportedThermostatFanModes_value; +} + +static void caps_thermostatFanMode_set_supportedThermostatFanModes_value(caps_thermostatFanMode_data_t *caps_data, const char **value, int array_size) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->supportedThermostatFanModes_value = (char **)value; + caps_data->supportedThermostatFanModes_array_size = array_size; +} + +static void caps_thermostatFanMode_attr_supportedThermostatFanModes_send(caps_thermostatFanMode_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int sequence_no; + + cap_evt = st_cap_attr_create_string_array((char *)caps_helper_thermostatFanMode.attr_supportedThermostatFanModes.name, + caps_data->supportedThermostatFanModes_array_size, caps_data->supportedThermostatFanModes_value, NULL); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send supportedThermostatFanModes value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + +static void caps_thermostatFanMode_cmd_fanAuto_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_thermostatFanMode_data_t *caps_data = (caps_thermostatFanMode_data_t *)usr_data; + const char *value = caps_helper_thermostatFanMode.attr_thermostatFanMode.values[CAPS_HELPER_THERMOSTAT_FAN_MODE_VALUE_AUTO]; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_thermostatFanMode_set_thermostatFanMode_value(caps_data, value); + if (caps_data && caps_data->cmd_fanAuto_usr_cb) + caps_data->cmd_fanAuto_usr_cb(caps_data); + caps_thermostatFanMode_attr_thermostatFanMode_send(caps_data); +} + +static void caps_thermostatFanMode_cmd_fanCirculate_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_thermostatFanMode_data_t *caps_data = (caps_thermostatFanMode_data_t *)usr_data; + const char *value = caps_helper_thermostatFanMode.attr_thermostatFanMode.values[CAPS_HELPER_THERMOSTAT_FAN_MODE_VALUE_CIRCULATE]; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_thermostatFanMode_set_thermostatFanMode_value(caps_data, value); + if (caps_data && caps_data->cmd_fanCirculate_usr_cb) + caps_data->cmd_fanCirculate_usr_cb(caps_data); + caps_thermostatFanMode_attr_thermostatFanMode_send(caps_data); +} + +static void caps_thermostatFanMode_cmd_fanOn_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_thermostatFanMode_data_t *caps_data = (caps_thermostatFanMode_data_t *)usr_data; + const char *value = caps_helper_thermostatFanMode.attr_thermostatFanMode.values[CAPS_HELPER_THERMOSTAT_FAN_MODE_VALUE_ON]; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_thermostatFanMode_set_thermostatFanMode_value(caps_data, value); + if (caps_data && caps_data->cmd_fanOn_usr_cb) + caps_data->cmd_fanOn_usr_cb(caps_data); + caps_thermostatFanMode_attr_thermostatFanMode_send(caps_data); +} + +static int caps_thermostatMode_attr_thermostatFanMode_str2idx(const char* value) +{ + int index; + + for (index = 0; index < CAPS_HELPER_THERMOSTAT_FAN_MODE_VALUE_MAX; index++) { + if (!strcmp(value, caps_helper_thermostatFanMode.attr_thermostatFanMode.values[index])) { + return index; + } + } + return -1; +} + +static void caps_thermostatFanMode_cmd_setThermostatFanMode_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_thermostatFanMode_data_t *caps_data = (caps_thermostatFanMode_data_t *)usr_data; + int index; + const char *value; + + printf("called [%s] func with : num_args:%u\n", __func__, cmd_data->num_args); + + index = caps_thermostatMode_attr_thermostatFanMode_str2idx(cmd_data->cmd_data[0].string); + if (index < 0) { + printf("%s is not supported value for setThermostatFanMode\n", cmd_data->cmd_data[0].string); + return; + } + + value = caps_helper_thermostatFanMode.attr_thermostatFanMode.values[index]; + caps_thermostatFanMode_set_thermostatFanMode_value(caps_data, value); + if (caps_data && caps_data->cmd_setThermostatFanMode_usr_cb) + caps_data->cmd_setThermostatFanMode_usr_cb(caps_data); + caps_thermostatFanMode_attr_thermostatFanMode_send(caps_data); +} + +static void caps_thermostatFanMode_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) +{ + caps_thermostatFanMode_data_t *caps_data = usr_data; + if (caps_data && caps_data->init_usr_cb) + caps_data->init_usr_cb(caps_data); + caps_thermostatFanMode_attr_thermostatFanMode_send(caps_data); + caps_thermostatFanMode_attr_supportedThermostatFanModes_send(caps_data); +} + +caps_thermostatFanMode_data_t *caps_thermostatFanMode_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data) +{ + caps_thermostatFanMode_data_t *caps_data = NULL; + int err; + + caps_data = malloc(sizeof(caps_thermostatFanMode_data_t)); + if (!caps_data) { + printf("fail to malloc for caps_thermostatFanMode_data\n"); + return NULL; + } + + memset(caps_data, 0, sizeof(caps_thermostatFanMode_data_t)); + + caps_data->handle = st_cap_handle_init(ctx, component, caps_helper_thermostatFanMode.id , caps_thermostatFanMode_init_cb, caps_data); + caps_data->init_usr_cb = init_usr_cb; + caps_data->usr_data = usr_data; + + caps_data->get_thermostatFanMode_value = caps_thermostatFanMode_get_thermostatFanMode_value; + caps_data->set_thermostatFanMode_value = caps_thermostatFanMode_set_thermostatFanMode_value; + caps_data->attr_thermostatFanMode_send = caps_thermostatFanMode_attr_thermostatFanMode_send; + + caps_data->get_supportedThermostatFanModes_value = caps_thermostatFanMode_get_supportedThermostatFanModes_value; + caps_data->set_supportedThermostatFanModes_value = caps_thermostatFanMode_set_supportedThermostatFanModes_value; + caps_data->attr_supportedThermostatFanModes_send = caps_thermostatFanMode_attr_supportedThermostatFanModes_send; + + caps_data->thermostatFanMode_value = (char *)caps_helper_thermostatFanMode.attr_thermostatFanMode.values[CAPS_HELPER_THERMOSTAT_FAN_MODE_VALUE_AUTO]; + caps_data->supportedThermostatFanModes_value = (char **)caps_helper_thermostatFanMode.attr_supportedThermostatFanModes.values; + caps_data->supportedThermostatFanModes_array_size = sizeof(caps_helper_thermostatFanMode.attr_supportedThermostatFanModes.values)/sizeof(char *); + + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_thermostatFanMode.cmd_fanAuto.name, caps_thermostatFanMode_cmd_fanAuto_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for fanAuto\n"); + return NULL; + } + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_thermostatFanMode.cmd_fanCirculate.name, caps_thermostatFanMode_cmd_fanCirculate_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for fanCirculate\n"); + return NULL; + } + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_thermostatFanMode.cmd_fanOn.name, caps_thermostatFanMode_cmd_fanOn_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for fanOn\n"); + return NULL; + } + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_thermostatFanMode.cmd_setThermostatFanMode.name, caps_thermostatFanMode_cmd_setThermostatFanMode_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for setThermostatFanMode\n"); + return NULL; + } + + return caps_data; +} diff --git a/apps/esp8266/st_thermostat/main/caps_thermostatFanMode.h b/apps/esp8266/st_thermostat/main/caps_thermostatFanMode.h new file mode 100644 index 00000000..b81eea26 --- /dev/null +++ b/apps/esp8266/st_thermostat/main/caps_thermostatFanMode.h @@ -0,0 +1,44 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include "caps/iot_caps_helper_thermostatFanMode.h" + +typedef struct caps_thermostatFanMode_data { + IOT_CAP_HANDLE* handle; + void *usr_data; + + char *thermostatFanMode_value; + const char *(*get_thermostatFanMode_value)(struct caps_thermostatFanMode_data *caps_data); + void (*set_thermostatFanMode_value)(struct caps_thermostatFanMode_data *caps_data, const char* value); + void (*attr_thermostatFanMode_send)(struct caps_thermostatFanMode_data *caps_data); + + char** supportedThermostatFanModes_value; + int supportedThermostatFanModes_array_size; + const char** (*get_supportedThermostatFanModes_value)(struct caps_thermostatFanMode_data *caps_data); + void (*set_supportedThermostatFanModes_value)(struct caps_thermostatFanMode_data *caps_data, const char** value, int array_size); + void (*attr_supportedThermostatFanModes_send)(struct caps_thermostatFanMode_data *caps_data); + + void (*init_usr_cb)(struct caps_thermostatFanMode_data *caps_data); + + void (*cmd_fanAuto_usr_cb)(struct caps_thermostatFanMode_data *caps_data); + void (*cmd_fanCirculate_usr_cb)(struct caps_thermostatFanMode_data *caps_data); + void (*cmd_fanOn_usr_cb)(struct caps_thermostatFanMode_data *caps_data); + void (*cmd_setThermostatFanMode_usr_cb)(struct caps_thermostatFanMode_data *caps_data); +} caps_thermostatFanMode_data_t; + +caps_thermostatFanMode_data_t *caps_thermostatFanMode_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data); diff --git a/apps/esp8266/st_thermostat/main/caps_thermostatHeatingSetpoint.c b/apps/esp8266/st_thermostat/main/caps_thermostatHeatingSetpoint.c new file mode 100644 index 00000000..2759b5a7 --- /dev/null +++ b/apps/esp8266/st_thermostat/main/caps_thermostatHeatingSetpoint.c @@ -0,0 +1,136 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include + +#include "st_dev.h" +#include "caps_thermostatHeatingSetpoint.h" + +#include "freertos/FreeRTOS.h" + +static int caps_thermostatHeatingSetpoint_get_heatingSetpoint_value(caps_thermostatHeatingSetpoint_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->heatingSetpoint_value; +} + +static void caps_thermostatHeatingSetpoint_set_heatingSetpoint_value(caps_thermostatHeatingSetpoint_data_t *caps_data, int value) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->heatingSetpoint_value = value; +} + +static const char *caps_thermostatHeatingSetpoint_get_heatingSetpoint_unit(caps_thermostatHeatingSetpoint_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->heatingSetpoint_unit; +} + +static void caps_thermostatHeatingSetpoint_set_heatingSetpoint_unit(caps_thermostatHeatingSetpoint_data_t *caps_data, const char *unit) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->heatingSetpoint_unit = (char *)unit; +} + +static void caps_thermostatHeatingSetpoint_attr_heatingSetpoint_send(caps_thermostatHeatingSetpoint_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int sequence_no; + + cap_evt = st_cap_attr_create_int((char *) caps_helper_thermostatHeatingSetpoint.attr_heatingSetpoint.name, caps_data->heatingSetpoint_value, caps_data->heatingSetpoint_unit); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send heatingSetpoint value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + +static void caps_thermostatHeatingSetpoint_cmd_set_heatingSetpoint_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_thermostatHeatingSetpoint_data_t *caps_data = usr_data; + int value; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + value = cmd_data->cmd_data[0].number; + + caps_thermostatHeatingSetpoint_set_heatingSetpoint_value(caps_data, value); + if (caps_data && caps_data->cmd_setHeatingSetpoint_usr_cb) + caps_data->cmd_setHeatingSetpoint_usr_cb(caps_data); + caps_thermostatHeatingSetpoint_attr_heatingSetpoint_send(caps_data); +} + +static void caps_thermostatHeatingSetpoint_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) +{ + caps_thermostatHeatingSetpoint_data_t *caps_data = usr_data; + if (caps_data && caps_data->init_usr_cb) + caps_data->init_usr_cb(caps_data); + caps_thermostatHeatingSetpoint_attr_heatingSetpoint_send(caps_data); +} + +caps_thermostatHeatingSetpoint_data_t *caps_thermostatHeatingSetpoint_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data) +{ + caps_thermostatHeatingSetpoint_data_t *caps_data = NULL; + int err; + + caps_data = malloc(sizeof(caps_thermostatHeatingSetpoint_data_t)); + if (!caps_data) { + printf("fail to malloc for caps_thermostatHeatingSetpoint_data\n"); + return NULL; + } + + memset(caps_data, 0, sizeof(caps_thermostatHeatingSetpoint_data_t)); + + caps_data->handle = st_cap_handle_init(ctx, component, caps_helper_thermostatHeatingSetpoint.id , caps_thermostatHeatingSetpoint_init_cb, caps_data); + caps_data->init_usr_cb = init_usr_cb; + caps_data->usr_data = usr_data; + + caps_data->get_heatingSetpoint_value = caps_thermostatHeatingSetpoint_get_heatingSetpoint_value; + caps_data->set_heatingSetpoint_value = caps_thermostatHeatingSetpoint_set_heatingSetpoint_value; + caps_data->get_heatingSetpoint_unit = caps_thermostatHeatingSetpoint_get_heatingSetpoint_unit; + caps_data->set_heatingSetpoint_unit = caps_thermostatHeatingSetpoint_set_heatingSetpoint_unit; + caps_data->attr_heatingSetpoint_send = caps_thermostatHeatingSetpoint_attr_heatingSetpoint_send; + + caps_data->heatingSetpoint_value = caps_helper_thermostatHeatingSetpoint.attr_heatingSetpoint.min; + caps_data->heatingSetpoint_unit = (char *)caps_helper_thermostatHeatingSetpoint.attr_heatingSetpoint.units[CAPS_HELPER_THERMOSTAT_HEATING_SETPOINT_UNIT_C]; + + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_thermostatHeatingSetpoint.cmd_setHeatingSetpoint.name, caps_thermostatHeatingSetpoint_cmd_set_heatingSetpoint_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for set_heatingSetpoint\n"); + return NULL; + } + + return caps_data; +} diff --git a/apps/esp8266/st_thermostat/main/caps_thermostatHeatingSetpoint.h b/apps/esp8266/st_thermostat/main/caps_thermostatHeatingSetpoint.h new file mode 100644 index 00000000..45f3b2e7 --- /dev/null +++ b/apps/esp8266/st_thermostat/main/caps_thermostatHeatingSetpoint.h @@ -0,0 +1,38 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include "caps/iot_caps_helper_thermostatHeatingSetpoint.h" + +typedef struct caps_thermostatHeatingSetpoint_data { + IOT_CAP_HANDLE* handle; + void *usr_data; + + int heatingSetpoint_value; + int (*get_heatingSetpoint_value)(struct caps_thermostatHeatingSetpoint_data *caps_data); + void (*set_heatingSetpoint_value)(struct caps_thermostatHeatingSetpoint_data *caps_data, int value); + char *heatingSetpoint_unit; + const char *(*get_heatingSetpoint_unit)(struct caps_thermostatHeatingSetpoint_data *caps_data); + void (*set_heatingSetpoint_unit)(struct caps_thermostatHeatingSetpoint_data *caps_data, const char *unit); + void (*attr_heatingSetpoint_send)(struct caps_thermostatHeatingSetpoint_data *caps_data); + + void (*init_usr_cb)(struct caps_thermostatHeatingSetpoint_data *caps_data); + + void (*cmd_setHeatingSetpoint_usr_cb)(struct caps_thermostatHeatingSetpoint_data *caps_data); +} caps_thermostatHeatingSetpoint_data_t; + +caps_thermostatHeatingSetpoint_data_t *caps_thermostatHeatingSetpoint_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data); diff --git a/apps/esp8266/st_thermostat/main/caps_thermostatMode.c b/apps/esp8266/st_thermostat/main/caps_thermostatMode.c new file mode 100644 index 00000000..d0898120 --- /dev/null +++ b/apps/esp8266/st_thermostat/main/caps_thermostatMode.c @@ -0,0 +1,276 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include + +#include "st_dev.h" +#include "caps_thermostatMode.h" + +#include "freertos/FreeRTOS.h" + +static const char *caps_thermostatMode_get_thermostatMode_value(caps_thermostatMode_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->thermostatMode_value; +} + +static void caps_thermostatMode_set_thermostatMode_value(caps_thermostatMode_data_t *caps_data, const char *value) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->thermostatMode_value = (char *)value; +} + +static void caps_thermostatMode_attr_thermostatMode_send(caps_thermostatMode_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int sequence_no; + + cap_evt = st_cap_attr_create_string(caps_helper_thermostatMode.attr_thermostatMode.name, + caps_data->thermostatMode_value, NULL); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send thermostatMode value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + +static const char **caps_thermostatMode_get_supportedThermostatModes_value(caps_thermostatMode_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return (const char **)caps_data->supportedThermostatModes_value; +} + +static void caps_thermostatMode_set_supportedThermostatModes_value(caps_thermostatMode_data_t *caps_data, const char **value, int array_size) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->supportedThermostatModes_value = (char **)value; + caps_data->supportedThermostatModes_array_size = array_size; +} + +static void caps_thermostatMode_attr_supportedThermostatModes_send(caps_thermostatMode_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int sequence_no; + + cap_evt = st_cap_attr_create_string_array((char *)caps_helper_thermostatMode.attr_supportedThermostatModes.name, + caps_data->supportedThermostatModes_array_size, caps_data->supportedThermostatModes_value, NULL); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send supportedThermostatModes value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + +static void caps_thermostatMode_cmd_auto_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_thermostatMode_data_t *caps_data = (caps_thermostatMode_data_t *)usr_data; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_thermostatMode_set_thermostatMode_value(caps_data, CAPS_HELPER_THERMOSTAT_MODE_VALUE_AUTO); + if (caps_data && caps_data->cmd_auto_usr_cb) + caps_data->cmd_auto_usr_cb(caps_data); + caps_thermostatMode_attr_thermostatMode_send(caps_data); +} + +static void caps_thermostatMode_cmd_cool_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_thermostatMode_data_t *caps_data = (caps_thermostatMode_data_t *)usr_data; + const char* value = caps_helper_thermostatMode.attr_thermostatMode.values[CAPS_HELPER_THERMOSTAT_MODE_VALUE_COOL]; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_thermostatMode_set_thermostatMode_value(caps_data, value); + if (caps_data && caps_data->cmd_cool_usr_cb) + caps_data->cmd_cool_usr_cb(caps_data); + caps_thermostatMode_attr_thermostatMode_send(caps_data); +} + +static void caps_thermostatMode_cmd_emergencyHeat_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_thermostatMode_data_t *caps_data = (caps_thermostatMode_data_t *)usr_data; + const char* value = caps_helper_thermostatMode.attr_thermostatMode.values[CAPS_HELPER_THERMOSTAT_MODE_VALUE_EMERGENCY_HEAT]; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_thermostatMode_set_thermostatMode_value(caps_data, value); + if (caps_data && caps_data->cmd_emergencyHeat_usr_cb) + caps_data->cmd_emergencyHeat_usr_cb(caps_data); + caps_thermostatMode_attr_thermostatMode_send(caps_data); +} + +static void caps_thermostatMode_cmd_heat_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_thermostatMode_data_t *caps_data = (caps_thermostatMode_data_t *)usr_data; + const char* value = caps_helper_thermostatMode.attr_thermostatMode.values[CAPS_HELPER_THERMOSTAT_MODE_VALUE_HEAT]; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_thermostatMode_set_thermostatMode_value(caps_data, value); + if (caps_data && caps_data->cmd_heat_usr_cb) + caps_data->cmd_heat_usr_cb(caps_data); + caps_thermostatMode_attr_thermostatMode_send(caps_data); +} + +static void caps_thermostatMode_cmd_off_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_thermostatMode_data_t *caps_data = (caps_thermostatMode_data_t *)usr_data; + const char* value = caps_helper_thermostatMode.attr_thermostatMode.values[CAPS_HELPER_THERMOSTAT_MODE_VALUE_OFF]; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + caps_thermostatMode_set_thermostatMode_value(caps_data, value); + if (caps_data && caps_data->cmd_off_usr_cb) + caps_data->cmd_off_usr_cb(caps_data); + caps_thermostatMode_attr_thermostatMode_send(caps_data); +} + +static int caps_thermostatMode_attr_thermostatMode_str2idx(const char* value) +{ + int index; + + for (index = 0; index < CAPS_HELPER_THERMOSTAT_MODE_VALUE_MAX; index++) { + if (!strcmp(value, caps_helper_thermostatMode.attr_thermostatMode.values[index])) { + return index; + } + } + return -1; +} + +static void caps_thermostatMode_cmd_setThermostatMode_cb(IOT_CAP_HANDLE *handle, + iot_cap_cmd_data_t *cmd_data, void *usr_data) +{ + caps_thermostatMode_data_t *caps_data = (caps_thermostatMode_data_t *)usr_data; + int index; + const char *value; + + printf("called [%s] func with : num_args:%u\n", + __func__, cmd_data->num_args); + + index = caps_thermostatMode_attr_thermostatMode_str2idx(cmd_data->cmd_data[0].string); + if (index < 0) { + printf("%s is not supported value for setThermostatMode\n", cmd_data->cmd_data[0].string); + return; + } + + value = caps_helper_thermostatMode.attr_thermostatMode.values[index]; + caps_thermostatMode_set_thermostatMode_value(caps_data, value); + if (caps_data && caps_data->cmd_setThermostatMode_usr_cb) + caps_data->cmd_setThermostatMode_usr_cb(caps_data); + caps_thermostatMode_attr_thermostatMode_send(caps_data); +} + +static void caps_thermostatMode_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) +{ + caps_thermostatMode_data_t *caps_data = usr_data; + if (caps_data && caps_data->init_usr_cb) + caps_data->init_usr_cb(caps_data); + caps_thermostatMode_attr_thermostatMode_send(caps_data); + caps_thermostatMode_attr_supportedThermostatModes_send(caps_data); +} + +caps_thermostatMode_data_t *caps_thermostatMode_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data) +{ + caps_thermostatMode_data_t *caps_data = NULL; + int err; + + caps_data = malloc(sizeof(caps_thermostatMode_data_t)); + if (!caps_data) { + printf("fail to malloc for caps_thermostatMode_data\n"); + return NULL; + } + + memset(caps_data, 0, sizeof(caps_thermostatMode_data_t)); + + caps_data->handle = st_cap_handle_init(ctx, component, caps_helper_thermostatMode.id , caps_thermostatMode_init_cb, caps_data); + caps_data->init_usr_cb = init_usr_cb; + caps_data->usr_data = usr_data; + + caps_data->get_thermostatMode_value = caps_thermostatMode_get_thermostatMode_value; + caps_data->set_thermostatMode_value = caps_thermostatMode_set_thermostatMode_value; + caps_data->attr_thermostatMode_send = caps_thermostatMode_attr_thermostatMode_send; + + caps_data->get_supportedThermostatModes_value = caps_thermostatMode_get_supportedThermostatModes_value; + caps_data->set_supportedThermostatModes_value = caps_thermostatMode_set_supportedThermostatModes_value; + caps_data->attr_supportedThermostatModes_send = caps_thermostatMode_attr_supportedThermostatModes_send; + + caps_data->thermostatMode_value = (char *)caps_helper_thermostatMode.attr_thermostatMode.values[CAPS_HELPER_THERMOSTAT_MODE_VALUE_AUTO]; + caps_data->supportedThermostatModes_value = (char **)caps_helper_thermostatMode.attr_supportedThermostatModes.values; + caps_data->supportedThermostatModes_array_size = sizeof(caps_helper_thermostatMode.attr_supportedThermostatModes.values)/sizeof(char *); + + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_thermostatMode.cmd_auto.name, caps_thermostatMode_cmd_auto_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for auto\n"); + return NULL; + } + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_thermostatMode.cmd_cool.name, caps_thermostatMode_cmd_cool_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for cool\n"); + return NULL; + } + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_thermostatMode.cmd_emergencyHeat.name, caps_thermostatMode_cmd_emergencyHeat_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for emergencyHeat\n"); + return NULL; + } + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_thermostatMode.cmd_heat.name, caps_thermostatMode_cmd_heat_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for heat\n"); + return NULL; + } + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_thermostatMode.cmd_off.name, caps_thermostatMode_cmd_off_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for off\n"); + return NULL; + } + err = st_cap_cmd_set_cb(caps_data->handle, caps_helper_thermostatMode.cmd_setThermostatMode.name, caps_thermostatMode_cmd_setThermostatMode_cb, caps_data); + if (err) { + printf("fail to set cmd_cb for setThermostatMode\n"); + return NULL; + } + + return caps_data; +} diff --git a/apps/esp8266/st_thermostat/main/caps_thermostatMode.h b/apps/esp8266/st_thermostat/main/caps_thermostatMode.h new file mode 100644 index 00000000..7c646501 --- /dev/null +++ b/apps/esp8266/st_thermostat/main/caps_thermostatMode.h @@ -0,0 +1,46 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include "caps/iot_caps_helper_thermostatMode.h" + +typedef struct caps_thermostatMode_data { + IOT_CAP_HANDLE* handle; + void *usr_data; + + char *thermostatMode_value; + const char *(*get_thermostatMode_value)(struct caps_thermostatMode_data *caps_data); + void (*set_thermostatMode_value)(struct caps_thermostatMode_data *caps_data, const char* value); + void (*attr_thermostatMode_send)(struct caps_thermostatMode_data *caps_data); + + char **supportedThermostatModes_value; + int supportedThermostatModes_array_size; + const char **(*get_supportedThermostatModes_value)(struct caps_thermostatMode_data *caps_data); + void (*set_supportedThermostatModes_value)(struct caps_thermostatMode_data *caps_data, const char **value, int array_size); + void (*attr_supportedThermostatModes_send)(struct caps_thermostatMode_data *caps_data); + + void (*init_usr_cb)(struct caps_thermostatMode_data *caps_data); + + void (*cmd_auto_usr_cb)(struct caps_thermostatMode_data *caps_data); + void (*cmd_cool_usr_cb)(struct caps_thermostatMode_data *caps_data); + void (*cmd_emergencyHeat_usr_cb)(struct caps_thermostatMode_data *caps_data); + void (*cmd_heat_usr_cb)(struct caps_thermostatMode_data *caps_data); + void (*cmd_off_usr_cb)(struct caps_thermostatMode_data *caps_data); + void (*cmd_setThermostatMode_usr_cb)(struct caps_thermostatMode_data *caps_data); +} caps_thermostatMode_data_t; + +caps_thermostatMode_data_t *caps_thermostatMode_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data); diff --git a/apps/esp8266/st_thermostat/main/caps_thermostatOperatingState.c b/apps/esp8266/st_thermostat/main/caps_thermostatOperatingState.c new file mode 100644 index 00000000..3d30c09a --- /dev/null +++ b/apps/esp8266/st_thermostat/main/caps_thermostatOperatingState.c @@ -0,0 +1,92 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include + +#include "st_dev.h" +#include "caps_thermostatOperatingState.h" + +#include "freertos/FreeRTOS.h" + +static const char *caps_thermostatOperatingState_get_thermostatOperatingState_value(caps_thermostatOperatingState_data_t *caps_data) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return NULL; + } + return caps_data->thermostatOperatingState_value; +} + +static void caps_thermostatOperatingState_set_thermostatOperatingState_value(caps_thermostatOperatingState_data_t *caps_data, const char *value) +{ + if (!caps_data) { + printf("caps_data is NULL\n"); + return; + } + caps_data->thermostatOperatingState_value = (char *)value; +} + +static void caps_thermostatOperatingState_attr_thermostatOperatingState_send(caps_thermostatOperatingState_data_t *caps_data) +{ + IOT_EVENT *cap_evt; + uint8_t evt_num = 1; + int sequence_no; + + cap_evt = st_cap_attr_create_string((char *)caps_helper_thermostatOperatingState.attr_thermostatOperatingState.name, + caps_data->thermostatOperatingState_value, NULL); + + sequence_no = st_cap_attr_send(caps_data->handle, evt_num, &cap_evt); + if (sequence_no < 0) + printf("fail to send thermostatOperatingState value\n"); + + printf("Sequence number return : %d\n", sequence_no); + st_cap_attr_free(cap_evt); +} + +static void caps_thermostatOperatingState_init_cb(IOT_CAP_HANDLE *handle, void *usr_data) +{ + caps_thermostatOperatingState_data_t *caps_data = usr_data; + if (caps_data && caps_data->init_usr_cb) + caps_data->init_usr_cb(caps_data); + caps_thermostatOperatingState_attr_thermostatOperatingState_send(caps_data); +} + +caps_thermostatOperatingState_data_t *caps_thermostatOperatingState_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data) +{ + caps_thermostatOperatingState_data_t *caps_data = NULL; + + caps_data = malloc(sizeof(caps_thermostatOperatingState_data_t)); + if (!caps_data) { + printf("fail to malloc for caps_thermostatOperatingState_data\n"); + return NULL; + } + + memset(caps_data, 0, sizeof(caps_thermostatOperatingState_data_t)); + + caps_data->handle = st_cap_handle_init(ctx, component, caps_helper_thermostatOperatingState.id , caps_thermostatOperatingState_init_cb, caps_data); + caps_data->init_usr_cb = init_usr_cb; + caps_data->usr_data = usr_data; + + caps_data->get_thermostatOperatingState_value = caps_thermostatOperatingState_get_thermostatOperatingState_value; + caps_data->set_thermostatOperatingState_value = caps_thermostatOperatingState_set_thermostatOperatingState_value; + caps_data->attr_thermostatOperatingState_send = caps_thermostatOperatingState_attr_thermostatOperatingState_send; + + caps_data->thermostatOperatingState_value = (char *)caps_helper_thermostatOperatingState.attr_thermostatOperatingState.values[CAPS_HELPER_THERMOSTAT_OPERATING_STATE_VALUE_IDLE]; + + return caps_data; +} diff --git a/apps/esp8266/st_thermostat/main/caps_thermostatOperatingState.h b/apps/esp8266/st_thermostat/main/caps_thermostatOperatingState.h new file mode 100644 index 00000000..47d38652 --- /dev/null +++ b/apps/esp8266/st_thermostat/main/caps_thermostatOperatingState.h @@ -0,0 +1,33 @@ +/* *************************************************************************** + * + * Copyright 2020 Samsung Electronics All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. + * + ****************************************************************************/ + +#include "caps/iot_caps_helper_thermostatOperatingState.h" + +typedef struct caps_thermostatOperatingState_data { + IOT_CAP_HANDLE* handle; + void *usr_data; + + char *thermostatOperatingState_value; + const char *(*get_thermostatOperatingState_value)(struct caps_thermostatOperatingState_data *caps_data); + void (*set_thermostatOperatingState_value)(struct caps_thermostatOperatingState_data *caps_data, const char *value); + void (*attr_thermostatOperatingState_send)(struct caps_thermostatOperatingState_data *caps_data); + + void (*init_usr_cb)(struct caps_thermostatOperatingState_data *caps_data); +} caps_thermostatOperatingState_data_t; + +caps_thermostatOperatingState_data_t *caps_thermostatOperatingState_initialize(IOT_CTX *ctx, const char *component, void *init_usr_cb, void *usr_data); diff --git a/apps/esp8266/st_thermostat/main/main.c b/apps/esp8266/st_thermostat/main/main.c index b72ea0d0..3da7458c 100644 --- a/apps/esp8266/st_thermostat/main/main.c +++ b/apps/esp8266/st_thermostat/main/main.c @@ -25,158 +25,44 @@ #include "freertos/FreeRTOS.h" #include "freertos/task.h" -#define POINT_UNIT "C" -#define TEMPERATURE_PERIOD_MS 2000 -#define TEMPERATURE_SIMUL 1 - -typedef enum thermostat_mode { - MODE_AUTO, - MODE_COOL, - MODE_ECO, - MODE_RUSH_HOUR, - MODE_EMERGENCY_HEAT, - MODE_HEAT, - MODE_OFF, - MODE_MAX_NUM, -} thermostat_mode_t; - -const char *thermostat_mode_str[MODE_MAX_NUM] = { - [MODE_AUTO] = "auto", - [MODE_COOL] = "cool", - [MODE_ECO] = "eco", - [MODE_RUSH_HOUR] = "rush hour", - [MODE_EMERGENCY_HEAT] = "emergency heat", - [MODE_HEAT] = "heat", - [MODE_OFF] = "off", -}; - -typedef enum thermostat_fan_mode { - FAN_MODE_AUTO, - FAN_MODE_CIRCULATE, - FAN_MODE_FOLLOWSCHEDULE, - FAN_MODE_ON, - FAN_MODE_MAX_NUM, -} thermostat_fan_mode_t; - -const char *thermostat_fan_mode_str[MODE_MAX_NUM] = { - [FAN_MODE_AUTO] = "auto", - [FAN_MODE_CIRCULATE] = "circulate", - [FAN_MODE_FOLLOWSCHEDULE] = "followschedule", - [FAN_MODE_ON] = "on", -}; - -typedef enum thermostat_op_sate { - OP_STATE_COOLING, - OP_STATE_FAN_ONLY, - OP_STATE_HEATING, - OP_STATE_IDLE, - OP_STATE_PENDING_COOL, - OP_STATE_PENDING_HEAT, - OP_STATE_VENT_ECONOMIZER, - OP_STATE_MAX_NUM, -} thermostat_op_state_t; - -const char *thermostat_op_state_str[MODE_MAX_NUM] = { - [OP_STATE_COOLING] = "cooling", - [OP_STATE_FAN_ONLY] = "fan only", - [OP_STATE_HEATING] = "heating", - [OP_STATE_IDLE] = "idle", - [OP_STATE_PENDING_COOL] = "pending cool", - [OP_STATE_PENDING_HEAT] = "pending heat", - [OP_STATE_VENT_ECONOMIZER] = "vent economizer", - NULL -}; - -extern const uint8_t onboarding_cfg_start[] asm("_binary_onboarding_config_json_start"); -extern const uint8_t onboarding_cfg_end[] asm("_binary_onboarding_config_json_end"); - -extern const uint8_t device_info_start[] asm("_binary_device_info_json_start"); -extern const uint8_t device_info_end[] asm("_binary_device_info_json_end"); +#include "caps_temperatureMeasurement.h" +#include "caps_thermostatCoolingSetpoint.h" +#include "caps_thermostatHeatingSetpoint.h" +#include "caps_thermostatFanMode.h" +#include "caps_thermostatMode.h" +#include "caps_thermostatOperatingState.h" -static iot_status_t g_iot_status; -static iot_stat_lv_t g_iot_stat_lv; -static IOT_CTX *ctx = NULL; -static IOT_CAP_HANDLE *gh_temperature = NULL; - -static double temperature; -static double cooling_point; -static double heating_point; -static thermostat_mode_t thermo_mode; -static thermostat_fan_mode_t thermo_fan_mode; -static thermostat_op_state_t thermo_op_state; - -static char strbuf[16] = {0}; - -static double thermostat_get_temperature(void); -static void temperature_send_cap_measurement(IOT_CAP_HANDLE *handle, double point); - -static char *util_double2str(double val) -{ - memset(strbuf, 0, sizeof(strbuf)); - - /* support up to one decimal point (e.g., 36.5) */ - snprintf(strbuf, sizeof(strbuf), "%d.%d", (int)val, ((int)(val * 10) % 10)); - - return strbuf; -} - -static double temperature_simul(void) -{ - static double delta = 2; - - if (temperature < heating_point) { - delta = 2; - printf("[Turn on Heater]\n"); - } else if (temperature > cooling_point) { - printf("[Turn on Cooler]\n"); - delta = -2; - } - - temperature += delta; - - return temperature; -} +#define TEMPERATURE_PERIOD_MS 10000 -static void temperature_update(void) -{ - double temp; - -#if TEMPERATURE_SIMUL - temp = temperature_simul(); -#else - temp = thermostat_get_temperature(); - temperature = temp; -#endif - if ((g_iot_status == IOT_STATUS_CONNECTING) && - (g_iot_stat_lv == IOT_STAT_LV_DONE)) { - temperature_send_cap_measurement(gh_temperature, temp); - } -} +// onboarding_config_start is null-terminated string +extern const uint8_t onboarding_config_start[] asm("_binary_onboarding_config_json_start"); +extern const uint8_t onboarding_config_end[] asm("_binary_onboarding_config_json_end"); -static void temperature_show(void) -{ - char buf[64]; - char *str; - int c = 0; +// device_info_start is null-terminated string +extern const uint8_t device_info_start[] asm("_binary_device_info_json_start"); +extern const uint8_t device_info_end[] asm("_binary_device_info_json_end"); - str = util_double2str(temperature); - c = sprintf(buf + c, "temperature: %s ", str); +static iot_status_t g_iot_status; +static iot_stat_lv_t g_iot_stat_lv; - str = util_double2str(cooling_point); - c += sprintf(buf + c, "cooling: %s ", str); +static IOT_CTX *ctx = NULL; - str = util_double2str(heating_point); - c += sprintf(buf + c, "heating: %s ", str); +struct caps_temperatureMeasurement_data *cap_temperature_handle; +struct caps_thermostatCoolingSetpoint_data *cap_coolingsetpoint_handle; +struct caps_thermostatHeatingSetpoint_data *cap_heatingsetpoint_handle; +struct caps_thermostatFanMode_data *cap_fanmode_handle; +struct caps_thermostatMode_data *cap_mode_handle; +struct caps_thermostatOperatingState_data *cap_opstate_handle; - printf("%s\n", buf); -} +const char *supported_fan_mode[] = { "auto", "on" }; +const char *supported_mode[] = { "auto", "cool", "eco" }; -static int thermostat_mode_str2idx(char *mode) +static int thermostat_fan_mode_str2idx(const char *mode) { int i; - for (i = 0; i < MODE_MAX_NUM; i++) { - if (!strcmp(mode, thermostat_mode_str[i])) + for (i = 0; i < CAPS_HELPER_THERMOSTAT_FAN_MODE_VALUE_MAX; i++) { + if (!strcmp(mode, caps_helper_thermostatFanMode.attr_thermostatFanMode.values[i])) return i; } @@ -185,12 +71,12 @@ static int thermostat_mode_str2idx(char *mode) return -1; } -static int thermostat_fan_mode_str2idx(char *mode) +static int thermostat_mode_str2idx(const char *mode) { int i; - for (i = 0; i < FAN_MODE_MAX_NUM; i++) { - if (!strcmp(mode, thermostat_fan_mode_str[i])) + for (i = 0; i < CAPS_HELPER_THERMOSTAT_MODE_VALUE_MAX; i++) { + if (!strcmp(mode, caps_helper_thermostatMode.attr_thermostatMode.values[i])) return i; } @@ -199,644 +85,135 @@ static int thermostat_fan_mode_str2idx(char *mode) return -1; } -static void thermostat_set_mode(thermostat_mode_t mode) +static void thermostat_set_mode(int mode) { /* * YOUR CODE: * implement a ability to control the mode of thermostat */ - printf("%s: changed mode = %s", __func__, - thermostat_mode_str[mode]); + caps_helper_thermostatMode.attr_thermostatMode.values[mode]); } -static void thermostat_set_fan_mode(thermostat_fan_mode_t mode) +static void thermostat_set_fan_mode(int mode) { /* * YOUR CODE: * implement a ability to control the fan mode of thermostat */ - printf("%s: changed fan mode = %s", __func__, - thermostat_fan_mode_str[mode]); -} - -static double thermostat_get_temperature(void) -{ - /* - * YOUR CODE: - * implement a ability to obtain the temperature - */ - - return 18.5; -} - -static thermostat_mode_t thermostat_get_mode(void) -{ - /* - * YOUR CODE: - * implement a ability to obtain the mode of thermostat - */ - - return MODE_AUTO; -} - -static thermostat_fan_mode_t thermostat_get_fan_mode(void) -{ - /* - * YOUR CODE: - * implement a ability to obtain the fan mode of thermostat - */ - - return FAN_MODE_AUTO; + caps_helper_thermostatFanMode.attr_thermostatFanMode.values[mode]); } -static double thermostat_get_cooling_point(void) +static void thermostat_set_cooling_point(double point) { /* * YOUR CODE: - * implement a ability to obtain the temperature for cooling + * implement a ability to set cooling point */ - - return 29.5; + printf("%s: changed cooling point = %lf", __func__, point); } -static double thermostat_get_heating_point(void) +static void thermostat_set_heating_point(double point) { /* * YOUR CODE: - * implement a ability to obtain the temperature for heating + * implement a ability to set heating point */ - - return 13.5; + printf("%s: changed heating point = %lf", __func__, point); } -static thermostat_op_state_t thermostat_get_op_state(void) +static double thermostat_get_temperature(void) { /* * YOUR CODE: - * implement a ability to obtain the operating state of thermostat + * implement a ability to obtain the temperature */ - - return OP_STATE_IDLE; -} - -static void temperature_send_cap_measurement(IOT_CAP_HANDLE *handle, double point) -{ - IOT_EVENT *evt; - uint8_t evt_num = 1; - int32_t seq_no; - char *str; - - str = util_double2str(point); - - if ((point < -460) || (point > 10000)) { - printf("%s: '%s' is out of range\n", __func__, str); - return; - } - - //printf("%s: point = %s\n", __func__, str); - - evt = st_cap_attr_create_number("temperature", point, POINT_UNIT); - - seq_no = st_cap_attr_send(handle, evt_num, &evt); - if (seq_no < 0) { - printf("%s: st_cap_attr_send is failed\n", __func__); - } - - st_cap_attr_free(evt); -} - -static void thermostat_send_cap_mode(IOT_CAP_HANDLE *handle, thermostat_mode_t mode) -{ - IOT_EVENT *evt; - uint8_t evt_num = 1; - int32_t seq_no; - - if (mode > MODE_MAX_NUM) { - printf("%s: '%d' is not supported mode\n", __func__, mode); - return; - } - - printf("%s: %s\n", __func__, (char *)thermostat_mode_str[mode]); - - evt = st_cap_attr_create_string("thermostatMode", - (char *)thermostat_mode_str[mode], NULL); - - seq_no = st_cap_attr_send(handle, evt_num, &evt); - if (seq_no < 0) { - printf("%s: st_cap_attr_send is failed\n", __func__); - } - - st_cap_attr_free(evt); -} - -static void thermostat_send_cap_supported_mode(IOT_CAP_HANDLE *handle) -{ - IOT_EVENT *evt; - uint8_t evt_num = 1; - int32_t seq_no; - - printf("%s\n", __func__); - - evt = st_cap_attr_create_string_array("supportedThermostatModes", - MODE_MAX_NUM, (char **)thermostat_mode_str, NULL); - - seq_no = st_cap_attr_send(handle, evt_num, &evt); - if (seq_no < 0) { - printf("%s: st_cap_attr_send is failed\n", __func__); - } - - st_cap_attr_free(evt); -} - -static void thermostat_send_cap_fan_mode(IOT_CAP_HANDLE *handle, thermostat_fan_mode_t mode) -{ - IOT_EVENT *evt; - uint8_t evt_num = 1; - int32_t seq_no; - - if (mode > FAN_MODE_MAX_NUM) { - printf("%s: '%d' is not supported mode\n", __func__, mode); - return; - } - - printf("%s: %s\n", __func__, (char *)thermostat_fan_mode_str[mode]); - - evt = st_cap_attr_create_string("thermostatFanMode", - (char *)thermostat_fan_mode_str[mode], NULL); - - seq_no = st_cap_attr_send(handle, evt_num, &evt); - if (seq_no < 0) { - printf("%s: st_cap_attr_send is failed\n", __func__); - } - - st_cap_attr_free(evt); -} - -static void thermostat_send_cap_supported_fan_mode(IOT_CAP_HANDLE *handle) -{ - IOT_EVENT *evt; - uint8_t evt_num = 1; - int32_t seq_no; - - printf("%s\n", __func__); - - evt = st_cap_attr_create_string_array("supportedThermostatFanModes", - FAN_MODE_MAX_NUM, (char **)thermostat_fan_mode_str, NULL); - - seq_no = st_cap_attr_send(handle, evt_num, &evt); - if (seq_no < 0) { - printf("%s: st_cap_attr_send is failed\n", __func__); - } - - st_cap_attr_free(evt); -} - -static void thermostat_send_cap_cooling(IOT_CAP_HANDLE *handle, double point) -{ - IOT_EVENT *evt; - uint8_t evt_num = 1; - int32_t seq_no; - char *str; - - str = util_double2str(point); - - if ((point < -460) || (point > 10000)) { - printf("%s: '%s' is out of range\n", __func__, str); - return; - } - - printf("%s: point = %s\n", __func__, str); - - evt = st_cap_attr_create_number("coolingSetpoint", point, POINT_UNIT); - - seq_no = st_cap_attr_send(handle, evt_num, &evt); - if (seq_no < 0) { - printf("%s: st_cap_attr_send is failed\n", __func__); - } - - st_cap_attr_free(evt); -} - -static void thermostat_send_cap_heating(IOT_CAP_HANDLE *handle, double point) -{ - IOT_EVENT *evt; - uint8_t evt_num = 1; - int32_t seq_no; - char *str; - - str = util_double2str(point); - - if ((point < -460) || (point > 10000)) { - printf("%s: '%s' is out of range\n", __func__, str); - return; - } - - printf("%s: point = %s\n", __func__, str); - - evt = st_cap_attr_create_number("heatingSetpoint", point, POINT_UNIT); - - seq_no = st_cap_attr_send(handle, evt_num, &evt); - if (seq_no < 0) { - printf("%s: st_cap_attr_send is failed\n", __func__); - } - - st_cap_attr_free(evt); -} - -static void thermostat_send_cap_op_state(IOT_CAP_HANDLE *handle, thermostat_op_state_t state) -{ - IOT_EVENT *evt; - uint8_t evt_num = 1; - int32_t seq_no; - - if (state > OP_STATE_MAX_NUM) { - printf("%s: '%d' is not supported state\n", __func__, state); - return; - } - - printf("%s: state = %s\n", __func__, (char *)thermostat_op_state_str[state]); - - evt = st_cap_attr_create_string("thermostatOperatingState", - (char *)thermostat_op_state_str[state], NULL); - - seq_no = st_cap_attr_send(handle, evt_num, &evt); - if (seq_no < 0) { - printf("%s: st_cap_attr_send is failed\n", __func__); - } - - st_cap_attr_free(evt); -} - -static void temperature_init_cb_measurement(IOT_CAP_HANDLE *handle, void *usr_data) -{ - temperature = thermostat_get_temperature(); - - temperature_send_cap_measurement(handle, temperature); -} - -static void thermostat_init_cb_mode(IOT_CAP_HANDLE *handle, void *usr_data) -{ - thermostat_send_cap_supported_mode(handle); - - thermo_mode = thermostat_get_mode(); - - thermostat_send_cap_mode(handle, thermo_mode); -} - -static void thermostat_init_cb_fan_mode(IOT_CAP_HANDLE *handle, void *usr_data) -{ - thermostat_send_cap_supported_fan_mode(handle); - - thermo_fan_mode = thermostat_get_fan_mode(); - - thermostat_send_cap_fan_mode(handle, thermo_fan_mode); -} - -static void thermostat_init_cb_cooling(IOT_CAP_HANDLE *handle, void *usr_data) -{ - cooling_point = thermostat_get_cooling_point(); - - thermostat_send_cap_cooling(handle, cooling_point); -} - -static void thermostat_init_cb_heating(IOT_CAP_HANDLE *handle, void *usr_data) -{ - heating_point = thermostat_get_heating_point(); - - thermostat_send_cap_heating(handle, heating_point); -} - -static void thermostat_init_cb_op_state(IOT_CAP_HANDLE *handle, void *usr_data) -{ - thermo_op_state = thermostat_get_op_state(); - - thermostat_send_cap_op_state(handle, thermo_op_state); -} - -static void thermostat_cmd_cb_mode_auto(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) -{ - thermostat_mode_t mode = MODE_AUTO; - - thermostat_set_mode(mode); - - thermostat_send_cap_mode(handle, mode); + return 18.5; } -static void thermostat_cmd_cb_mode_cool(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) +static void cap_temperatureMeasurement_init_cb(struct caps_temperatureMeasurement_data *caps_data) { - thermostat_mode_t mode = MODE_COOL; + const int initial_temperature_value = thermostat_get_temperature(); + const char *temperature_unit = + caps_helper_temperatureMeasurement.attr_temperature.units[CAPS_HELPER_TEMPERATURE_MEASUREMENT_UNIT_C]; - thermostat_set_mode(mode); - - thermostat_send_cap_mode(handle, mode); + caps_data->set_temperature_value(caps_data, initial_temperature_value); + caps_data->set_temperature_unit(caps_data, temperature_unit); } -static void thermostat_cmd_cb_mode_emergencyheat(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) +static void cap_thermostatCoolingSetpoint_init_cb(struct caps_thermostatCoolingSetpoint_data *caps_data) { - thermostat_mode_t mode = MODE_EMERGENCY_HEAT; - - thermostat_set_mode(mode); + const int initial_cooling_point_value = 30.5; + const char *cooling_point_unit = + caps_helper_thermostatCoolingSetpoint.attr_coolingSetpoint.units[CAPS_HELPER_THERMOSTAT_COOLING_SETPOINT_UNIT_C]; - thermostat_send_cap_mode(handle, mode); + caps_data->set_coolingSetpoint_value(caps_data, initial_cooling_point_value); + caps_data->set_coolingSetpoint_unit(caps_data, cooling_point_unit); } -static void thermostat_cmd_cb_mode_heat(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) +static void cap_thermostatHeatingSetpoint_init_cb(struct caps_thermostatHeatingSetpoint_data *caps_data) { - thermostat_mode_t mode = MODE_HEAT; + const int initial_heating_point_value = 13.5; + const char *heating_point_unit = + caps_helper_thermostatHeatingSetpoint.attr_heatingSetpoint.units[CAPS_HELPER_THERMOSTAT_HEATING_SETPOINT_UNIT_C]; - thermostat_set_mode(mode); - - thermostat_send_cap_mode(handle, mode); + caps_data->set_heatingSetpoint_value(caps_data, initial_heating_point_value); + caps_data->set_heatingSetpoint_unit(caps_data, heating_point_unit); } -static void thermostat_cmd_cb_mode_off(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) +static void cap_thermostatFanMode_init_cb(struct caps_thermostatFanMode_data *caps_data) { - thermostat_mode_t mode = MODE_OFF; - - thermostat_set_mode(mode); + const char *initial_fan_mode = + caps_helper_thermostatFanMode.attr_thermostatFanMode.values[CAPS_HELPER_THERMOSTAT_FAN_MODE_VALUE_AUTO]; - thermostat_send_cap_mode(handle, mode); + caps_data->set_thermostatFanMode_value(caps_data, initial_fan_mode); + caps_data->set_supportedThermostatFanModes_value(caps_data, supported_fan_mode, sizeof(supported_fan_mode)/sizeof(char *)); } -static void thermostat_cmd_cb_mode_set(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) +static void cap_thermostatMode_init_cb(struct caps_thermostatMode_data *caps_data) { - char *mode_str; - int mode_num; + const char* initial_mode = + caps_helper_thermostatMode.attr_thermostatMode.values[CAPS_HELPER_THERMOSTAT_MODE_VALUE_AUTO]; - if (cmd_data->num_args != 1) { - printf("%s: invalid args (%d)\n", __func__, - cmd_data->num_args); - } + caps_data->set_thermostatMode_value(caps_data, initial_mode); + caps_data->set_supportedThermostatModes_value(caps_data, supported_mode, sizeof(supported_mode)/sizeof(char *)); - mode_str = cmd_data->cmd_data[0].string; - mode_num = thermostat_mode_str2idx(mode_str); - if (mode_num < 0) { - printf("%s: '%s' is not supported mode\n", - __func__, mode_str); - } else { - thermo_mode = mode_num; - thermostat_set_mode(thermo_mode); - } - - thermostat_send_cap_mode(handle, thermo_mode); } -static void thermostat_cmd_cb_fan_mode_auto(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) +static void cap_thermostatOperatingState_init_cb(struct caps_thermostatOperatingState_data *caps_data) { - thermostat_fan_mode_t mode = FAN_MODE_AUTO; - - thermostat_set_fan_mode(mode); - - thermostat_send_cap_fan_mode(handle, mode); + const char* initial_op_state = + caps_helper_thermostatOperatingState.attr_thermostatOperatingState.values[CAPS_HELPER_THERMOSTAT_OPERATING_STATE_VALUE_IDLE]; + caps_data->set_thermostatOperatingState_value(caps_data, initial_op_state); } -static void thermostat_cmd_cb_fan_mode_circulate(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) +static void cap_thermostatCoolingSetpoint_cmd_cb(struct caps_thermostatCoolingSetpoint_data *caps_data) { - thermostat_fan_mode_t mode = FAN_MODE_CIRCULATE; - - thermostat_set_fan_mode(mode); - - thermostat_send_cap_fan_mode(handle, mode); + int point = caps_data->get_coolingSetpoint_value(caps_data); + thermostat_set_cooling_point(point); } -static void thermostat_cmd_cb_fan_mode_on(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) +static void cap_thermostatHeatingSetpoint_cmd_cb(struct caps_thermostatHeatingSetpoint_data *caps_data) { - thermostat_fan_mode_t mode = FAN_MODE_ON; - - thermostat_set_fan_mode(mode); - - thermostat_send_cap_fan_mode(handle, mode); + int point = caps_data->get_heatingSetpoint_value(caps_data); + thermostat_set_heating_point(point); } -static void thermostat_cmd_cb_fan_mode_set(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) +static void cap_thermostatFanMode_cmd_cb(struct caps_thermostatFanMode_data *caps_data) { - char *mode_str; - int mode_num; - - if (cmd_data->num_args != 1) { - printf("%s: invalid args (%d)\n", __func__, - cmd_data->num_args); - } - - mode_str = cmd_data->cmd_data[0].string; - mode_num = thermostat_fan_mode_str2idx(mode_str); - if (mode_num < 0) { - printf("%s: not supported mode\n", __func__); - } else { - thermo_fan_mode = mode_num; - thermostat_set_mode(thermo_fan_mode); - } - - thermostat_send_cap_fan_mode(handle, thermo_fan_mode); + const char *fan_mode = caps_data->get_thermostatFanMode_value(caps_data); + thermostat_set_fan_mode( thermostat_fan_mode_str2idx(fan_mode)) ; } -static void thermostat_cmd_cb_cooling(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) +static void cap_thermostatMode_cmd_cb(struct caps_thermostatMode_data *caps_data) { - double point; - char *str; - - if (cmd_data->num_args != 1) { - printf("%s: invalid args (%d)\n", __func__, - cmd_data->num_args); - } - - point = cmd_data->cmd_data[0].number; - - if (point > heating_point) { - cooling_point = point; - str = util_double2str(cooling_point); - printf("%s: changed to %s\n", __func__, str); - } else { - str = util_double2str(point); - printf("%s: '%s' is invalid\n", __func__, str); - } - - thermostat_send_cap_cooling(handle, cooling_point); + const char *mode = caps_data->get_thermostatMode_value(caps_data); + thermostat_set_mode( thermostat_mode_str2idx(mode) ); } -static void thermostat_cmd_cb_heating(IOT_CAP_HANDLE *handle, - iot_cap_cmd_data_t *cmd_data, void *usr_data) -{ - double point; - char *str; - - if (cmd_data->num_args != 1) { - printf("%s: invalid args (%d)\n", __func__, - cmd_data->num_args); - } - - point = cmd_data->cmd_data[0].number; - - if (point < cooling_point) { - heating_point = point; - str = util_double2str(heating_point); - printf("%s: changed to %s\n", __func__, str); - } else { - str = util_double2str(point); - printf("%s: '%s' is invalid\n", __func__, str); - } - - thermostat_send_cap_heating(handle, heating_point); -} -static void temperature_init_cap_measurement(IOT_CTX *ctx) -{ - IOT_CAP_HANDLE *handle; - - handle = st_cap_handle_init(ctx, "main", "temperatureMeasurement", - temperature_init_cb_measurement, NULL); - if (handle == NULL) { - printf("%s: st_cap_handle_init is failed\n", __func__); - } - - gh_temperature = handle; -} - -static void thermostat_init_cap_mode(IOT_CTX *ctx) -{ - IOT_CAP_HANDLE *handle; - int st_err; - - handle = st_cap_handle_init(ctx, "main", "thermostatMode", - thermostat_init_cb_mode, NULL); - if (handle == NULL) { - printf("%s: st_cap_handle_init is failed\n", __func__); - } - - st_err = st_cap_cmd_set_cb(handle, "auto", - thermostat_cmd_cb_mode_auto, NULL); - if (st_err) { - printf("%s: st_cap_cmd_set_cb is failed", __func__); - } - - st_err = st_cap_cmd_set_cb(handle, "cool", - thermostat_cmd_cb_mode_cool, NULL); - if (st_err) { - printf("%s: st_cap_cmd_set_cb is failed", __func__); - } - - st_err = st_cap_cmd_set_cb(handle, "emergencyHeat", - thermostat_cmd_cb_mode_emergencyheat, NULL); - if (st_err) { - printf("%s: st_cap_cmd_set_cb is failed", __func__); - } - - st_err = st_cap_cmd_set_cb(handle, "heat", - thermostat_cmd_cb_mode_heat, NULL); - if (st_err) { - printf("%s: st_cap_cmd_set_cb is failed", __func__); - } - - st_err = st_cap_cmd_set_cb(handle, "off", - thermostat_cmd_cb_mode_off, NULL); - if (st_err) { - printf("%s: st_cap_cmd_set_cb is failed", __func__); - } - - st_err = st_cap_cmd_set_cb(handle, "setThermostatMode", - thermostat_cmd_cb_mode_set, NULL); - if (st_err) { - printf("%s: st_cap_cmd_set_cb is failed", __func__); - } -} - -static void thermostat_init_cap_fan_mode(IOT_CTX *ctx) -{ - IOT_CAP_HANDLE *handle; - int st_err; - - handle = st_cap_handle_init(ctx, "main", "thermostatFanMode", - thermostat_init_cb_fan_mode, NULL); - if (handle == NULL) { - printf("%s: st_cap_handle_init is failed\n", __func__); - } - - st_err = st_cap_cmd_set_cb(handle, "fanAuto", - thermostat_cmd_cb_fan_mode_auto, NULL); - if (st_err) { - printf("%s: st_cap_cmd_set_cb is failed", __func__); - } - - st_err = st_cap_cmd_set_cb(handle, "fanCirculate", - thermostat_cmd_cb_fan_mode_circulate, NULL); - if (st_err) { - printf("%s: st_cap_cmd_set_cb is failed", __func__); - } - - st_err = st_cap_cmd_set_cb(handle, "fanOn", - thermostat_cmd_cb_fan_mode_on, NULL); - if (st_err) { - printf("%s: st_cap_cmd_set_cb is failed", __func__); - } - - st_err = st_cap_cmd_set_cb(handle, "setThermostatFanMode", - thermostat_cmd_cb_fan_mode_set, NULL); - if (st_err) { - printf("%s: st_cap_cmd_set_cb is failed\n", __func__); - } -} - -static void thermostat_init_cap_cooling(IOT_CTX *ctx) -{ - IOT_CAP_HANDLE *handle; - int st_err; - - handle = st_cap_handle_init(ctx, "main", "thermostatCoolingSetpoint", - thermostat_init_cb_cooling, NULL); - if (handle == NULL) { - printf("%s: st_cap_handle_init is failed\n", __func__); - } - - st_err = st_cap_cmd_set_cb(handle, "setCoolingSetpoint", - thermostat_cmd_cb_cooling, NULL); - if (st_err) { - printf("%s: st_cap_cmd_set_cb is failed\n", __func__); - } -} - -static void thermostat_init_cap_heating(IOT_CTX *ctx) -{ - IOT_CAP_HANDLE *handle; - int st_err; - - handle = st_cap_handle_init(ctx, "main", "thermostatHeatingSetpoint", - thermostat_init_cb_heating, NULL); - if (handle == NULL) { - printf("%s: st_cap_handle_init is failed\n", __func__); - } - - st_err = st_cap_cmd_set_cb(handle, "setHeatingSetpoint", - thermostat_cmd_cb_heating, NULL); - if (st_err) { - printf("%s: st_cap_cmd_set_cb is failed\n", __func__); - } -} - -static void thermostat_init_cap_op_state(IOT_CTX *ctx) -{ - IOT_CAP_HANDLE *handle; - - handle = st_cap_handle_init(ctx, "main", "thermostatOperatingState", - thermostat_init_cb_op_state, NULL); - if (handle == NULL) { - printf("%s: st_cap_handle_init is failed\n", __func__); - } -} - -static void iot_noti_cb(iot_noti_data_t *noti_data, void *noti_usr_data) +void iot_noti_cb(iot_noti_data_t *noti_data, void *noti_usr_data) { printf("Notification message received\n"); @@ -844,47 +221,25 @@ static void iot_noti_cb(iot_noti_data_t *noti_data, void *noti_usr_data) printf("[device deleted]\n"); } else if (noti_data->type == IOT_NOTI_TYPE_RATE_LIMIT) { printf("[rate limit] Remaining time:%d, sequence number:%d\n", - noti_data->raw.rate_limit.remainingTime, - noti_data->raw.rate_limit.sequenceNumber); + noti_data->raw.rate_limit.remainingTime, noti_data->raw.rate_limit.sequenceNumber); } } static void iot_status_cb(iot_status_t status, iot_stat_lv_t stat_lv, void *usr_data) { - const char *status_str[] = { - [IOT_STATUS_IDLE] = "idle", - [IOT_STATUS_PROVISIONING] = "provisioning", - [IOT_STATUS_NEED_INTERACT] = "need interact", - [IOT_STATUS_CONNECTING] = "connecting", - }; - - const char *stat_lv_str[] = { - [IOT_STAT_LV_STAY] = "stay", - [IOT_STAT_LV_START] = "start", - [IOT_STAT_LV_DONE] = "done", - [IOT_STAT_LV_FAIL] = "fail", - }; - g_iot_status = status; g_iot_stat_lv = stat_lv; - printf("status: %s, stat: %s\n", - (char *)status_str[g_iot_status], - (char *)stat_lv_str[g_iot_stat_lv]); -} - -static unsigned int task_get_current_ms(void) -{ - return (xTaskGetTickCountFromISR() * portTICK_PERIOD_MS); + printf("status: %d, stat: %d\n", g_iot_status, g_iot_stat_lv); } static void thermostat_task(void *arg) { TimeOut_t temperature_timeout; TickType_t temperature_period_tick = pdMS_TO_TICKS(TEMPERATURE_PERIOD_MS); - - vTaskDelay(20000 / portTICK_PERIOD_MS); + int temperature; + vTaskDelay(TEMPERATURE_PERIOD_MS / portTICK_PERIOD_MS); vTaskSetTimeOutState(&temperature_timeout); @@ -893,45 +248,76 @@ static void thermostat_task(void *arg) vTaskSetTimeOutState(&temperature_timeout); temperature_period_tick = pdMS_TO_TICKS(TEMPERATURE_PERIOD_MS); - temperature_update(); - temperature_show(); + temperature = thermostat_get_temperature(); + cap_temperature_handle->set_temperature_value(cap_temperature_handle, temperature); + cap_temperature_handle->attr_temperature_send(cap_temperature_handle); } - vTaskDelay(10 / portTICK_PERIOD_MS); + vTaskDelay(100 / portTICK_PERIOD_MS); } } void app_main(void) { - unsigned char *onboarding_cfg = (unsigned char *)onboarding_cfg_start; - unsigned int onboarding_cfg_len = onboarding_cfg_end - onboarding_cfg_start; - unsigned char *device_info = (unsigned char *)device_info_start; - unsigned int device_info_len = device_info_end - device_info_start; - int st_err; + /** + SmartThings Device SDK(STDK) aims to make it easier to develop IoT devices by providing + additional st_iot_core layer to the existing chip vendor SW Architecture. - ctx = st_conn_init(onboarding_cfg, onboarding_cfg_len, device_info, device_info_len); - if (ctx != NULL) { - st_err = st_conn_set_noti_cb(ctx, iot_noti_cb, NULL); - if (st_err) { - printf("st_conn_set_noti_cb is failed\n"); - } + That is, you can simply develop a basic application by just calling the APIs provided by st_iot_core layer + like below. st_iot_core currently offers 14 API. + + //create a iot context + 1. st_conn_init(); - temperature_init_cap_measurement(ctx); + //create a handle to process capability + 2. st_cap_handle_init(); - thermostat_init_cap_mode(ctx); + //register a callback function to process capability command when it comes from the SmartThings Server. + 3. st_cap_cmd_set_cb(); - thermostat_init_cap_fan_mode(ctx); + //needed when it is necessary to keep monitoring the device status + 4. user_defined_task() - thermostat_init_cap_cooling(ctx); + //process on-boarding procedure. There is nothing more to do on the app side than call the API. + 5. st_conn_start(); + */ + + unsigned char *onboarding_config = (unsigned char *) onboarding_config_start; + unsigned int onboarding_config_len = onboarding_config_end - onboarding_config_start; + unsigned char *device_info = (unsigned char *) device_info_start; + unsigned int device_info_len = device_info_end - device_info_start; - thermostat_init_cap_heating(ctx); + int iot_err; - thermostat_init_cap_op_state(ctx); + // 1. create a iot context + ctx = st_conn_init(onboarding_config, onboarding_config_len, device_info, device_info_len); + if (ctx != NULL) { + iot_err = st_conn_set_noti_cb(ctx, iot_noti_cb, NULL); + if (iot_err) + printf("fail to set notification callback function\n"); + + // 2. create a handle to process capability + // implement init_callback function + cap_temperature_handle = caps_temperatureMeasurement_initialize(ctx, "main", cap_temperatureMeasurement_init_cb, NULL); + cap_coolingsetpoint_handle = caps_thermostatCoolingSetpoint_initialize(ctx, "main", cap_thermostatCoolingSetpoint_init_cb, NULL); + cap_heatingsetpoint_handle = caps_thermostatHeatingSetpoint_initialize(ctx, "main", cap_thermostatHeatingSetpoint_init_cb, NULL); + cap_fanmode_handle = caps_thermostatFanMode_initialize(ctx, "main", cap_thermostatFanMode_init_cb, NULL); + cap_mode_handle = caps_thermostatMode_initialize(ctx, "main", cap_thermostatMode_init_cb, NULL); + cap_opstate_handle = caps_thermostatOperatingState_initialize(ctx, "main", cap_thermostatOperatingState_init_cb, NULL); + + // 3. register a callback function to process capability command when it comes from the SmartThings Server + // implement callback function + cap_coolingsetpoint_handle->cmd_setCoolingSetpoint_usr_cb = cap_thermostatCoolingSetpoint_cmd_cb; + cap_heatingsetpoint_handle->cmd_setHeatingSetpoint_usr_cb = cap_thermostatHeatingSetpoint_cmd_cb; + cap_fanmode_handle->cmd_setThermostatFanMode_usr_cb = cap_thermostatFanMode_cmd_cb; + cap_mode_handle->cmd_setThermostatMode_usr_cb = cap_thermostatMode_cmd_cb; } else { - printf("st_conn_init is failed\n"); + printf("fail to create the iot_context\n"); } + // 4. needed when it is necessary to keep monitoring the device status xTaskCreate(thermostat_task, "thermostat_task", 2048, NULL, 10, NULL); + // 5. process on-boarding procedure. There is nothing more to do on the app side than call the API. st_conn_start(ctx, (st_status_cb)&iot_status_cb, IOT_STATUS_ALL, NULL, NULL); }