407 lines
13 KiB
C
407 lines
13 KiB
C
// Copyright 2017-2019 Espressif Systems (Shanghai) PTE LTD
|
|
//
|
|
// 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.
|
|
|
|
#ifndef _TIME_SCENE_SERVER_H_
|
|
#define _TIME_SCENE_SERVER_H_
|
|
|
|
#include "server_common.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* 1. Mesh defines times based on International Atomic Time (TAI). The base
|
|
* representation of times is the number of seconds after 00:00:00 TAI
|
|
* on 2000-01-01 (that is, 1999-12-31 T23:59:28 UTC).
|
|
* 2. UTC: Coordinated Universal Time. For more information, please refer
|
|
* to https://time.is/zh/UTC
|
|
* 3. For the algorithm used for the transfer between TAI and UTC, please
|
|
* refer to Mesh Model Spec Section 5.1.1
|
|
*/
|
|
|
|
#define UNKNOWN_TAI_SECONDS 0x0000000000
|
|
#define UNKNOWN_TAI_ZONE_CHANGE 0x0000000000
|
|
#define UNKNOWN_TAI_DELTA_CHANGE 0x0000000000
|
|
#define TAI_UTC_DELTA_MAX_VALUE 0x7FFF
|
|
#define TAI_SECONDS_LEN 0x05
|
|
#define TAI_OF_ZONE_CHANGE_LEN 0x05
|
|
#define TAI_OF_DELTA_CHANGE_LEN 0x05
|
|
|
|
#define INVALID_SCENE_NUMBER 0x0000
|
|
#define SCENE_NUMBER_LEN 0x02
|
|
|
|
#define SCHEDULE_YEAR_ANY_YEAR 0x64
|
|
|
|
#define SCHEDULE_DAY_ANY_DAY 0x00
|
|
|
|
#define SCHEDULE_HOUR_ANY_HOUR 0x18
|
|
#define SCHEDULE_HOUR_ONCE_A_DAY 0x19
|
|
|
|
#define SCHEDULE_SEC_ANY_OF_HOUR 0x3C
|
|
#define SCHEDULE_SEC_EVERY_15_MIN 0x3D
|
|
#define SCHEDULE_SEC_EVERY_20_MIN 0x3E
|
|
#define SCHEDULE_SEC_ONCE_AN_HOUR 0x3F
|
|
|
|
#define SCHEDULE_SEC_ANY_OF_MIN 0x3C
|
|
#define SCHEDULE_SEC_EVERY_15_SEC 0x3D
|
|
#define SCHEDULE_SEC_EVERY_20_SEC 0x3E
|
|
#define SCHEDULE_SEC_ONCE_AN_MIN 0x3F
|
|
|
|
#define SCHEDULE_ACT_TURN_OFF 0x00
|
|
#define SCHEDULE_ACT_TURN_ON 0x01
|
|
#define SCHEDULE_ACT_SCENE_RECALL 0x02
|
|
#define SCHEDULE_ACT_NO_ACTION 0x0F
|
|
|
|
#define SCHEDULE_SCENE_NO_SCENE 0x0000
|
|
|
|
#define SCHEDULE_ENTRY_MAX_INDEX 0x0F
|
|
|
|
#define TIME_NONE 0x00
|
|
#define TIME_AUTHORITY 0x01
|
|
#define TIME_RELAY 0x02
|
|
#define TIME_CLINET 0x03
|
|
|
|
#define SCENE_SUCCESS 0x00
|
|
#define SCENE_REG_FULL 0x01
|
|
#define SCENE_NOT_FOUND 0x02
|
|
|
|
/**
|
|
* The Time state represents the present TAI time, the current TAI-UTC Delta
|
|
* and local time zone offset, and the next change to each of the latter
|
|
* (e.g., because of a switch from winter to summer time or an announced leap
|
|
* second). It consists of 10 fields with a total size of 183 bits.
|
|
*/
|
|
struct bt_mesh_time_state {
|
|
struct {
|
|
u8_t tai_seconds[5];
|
|
u8_t subsecond;
|
|
u8_t uncertainty;
|
|
u8_t time_zone_offset_curr;
|
|
u8_t time_zone_offset_new;
|
|
u8_t tai_zone_change[5];
|
|
u16_t time_authority : 1,
|
|
tai_utc_delta_curr : 15;
|
|
u16_t tai_utc_delta_new : 15;
|
|
u8_t tai_delta_change[5];
|
|
} time;
|
|
u8_t time_role;
|
|
};
|
|
|
|
struct bt_mesh_time_srv {
|
|
struct bt_mesh_model *model;
|
|
struct bt_mesh_server_rsp_ctrl rsp_ctrl;
|
|
struct bt_mesh_time_state *state;
|
|
};
|
|
|
|
struct bt_mesh_time_setup_srv {
|
|
struct bt_mesh_model *model;
|
|
struct bt_mesh_server_rsp_ctrl rsp_ctrl;
|
|
struct bt_mesh_time_state *state;
|
|
};
|
|
|
|
struct scene_register {
|
|
u16_t scene_number;
|
|
u8_t scene_type; /* Indicate the type of scene value */
|
|
/**
|
|
* Scene value may use a union to represent later, the union contains
|
|
* structures of all the model states which can be stored in a scene.
|
|
*/
|
|
struct net_buf_simple *scene_value;
|
|
};
|
|
|
|
/**
|
|
* Scenes serve as memory banks for storage of states (e.g., a power level
|
|
* or a light level/color). Values of states of an element can be stored
|
|
* as a scene and can be recalled later from the scene memory.
|
|
*
|
|
* A scene is represented by a Scene Number, which is a 16-bit non-zero,
|
|
* mesh-wide value. (There can be a maximum of 65535 scenes in a mesh
|
|
* network.) The meaning of a scene, as well as the state storage container
|
|
* associated with it, are determined by a model.
|
|
*
|
|
* The Scenes state change may start numerous parallel model transitions.
|
|
* In that case, each individual model handles the transition internally.
|
|
*
|
|
* The scene transition is defined as a group of individual model transitions
|
|
* started by a Scene Recall operation. The scene transition is in progress
|
|
* when at least one transition from the group of individual model transitions
|
|
* is in progress.
|
|
*/
|
|
struct bt_mesh_scenes_state {
|
|
const u16_t scene_count;
|
|
struct scene_register *scenes;
|
|
|
|
/**
|
|
* The Current Scene state is a 16-bit value that contains either the Scene
|
|
* Number of the currently active scene or a value of 0x0000 when no scene
|
|
* is active.
|
|
*
|
|
* When a Scene Store operation or a Scene Recall operation completes with
|
|
* success, the Current Scene state value shall be to the Scene Number used
|
|
* during that operation.
|
|
*
|
|
* When the Current Scene Number is deleted from a Scene Register state as a
|
|
* result of Scene Delete operation, the Current Scene state shall be set to
|
|
* 0x0000.
|
|
*
|
|
* When any of the element's state that is marked as “Stored with Scene” has
|
|
* changed not as a result of a Scene Recall operation, the value of the
|
|
* Current Scene state shall be set to 0x0000.
|
|
*
|
|
* When a scene transition is in progress, the value of the Current Scene
|
|
* state shall be set to 0x0000.
|
|
*/
|
|
u16_t current_scene;
|
|
|
|
/**
|
|
* The Target Scene state is a 16-bit value that contains the target Scene
|
|
* Number when a scene transition is in progress.
|
|
*
|
|
* When the scene transition is in progress and the target Scene Number is
|
|
* deleted from a Scene Register state as a result of Scene Delete operation,
|
|
* the Target Scene state shall be set to 0x0000.
|
|
*
|
|
* When the scene transition is in progress and a new Scene Number is stored
|
|
* in the Scene Register as a result of Scene Store operation, the Target
|
|
* Scene state shall be set to the new Scene Number.
|
|
*
|
|
* When the scene transition is not in progress, the value of the Target Scene
|
|
* state shall be set to 0x0000.
|
|
*/
|
|
u16_t target_scene;
|
|
|
|
/* Indicate the status code for the last operation */
|
|
u8_t status_code;
|
|
|
|
/* Indicate if scene transition is in progress */
|
|
bool in_progress;
|
|
};
|
|
|
|
struct bt_mesh_scene_srv {
|
|
struct bt_mesh_model *model;
|
|
struct bt_mesh_server_rsp_ctrl rsp_ctrl;
|
|
struct bt_mesh_scenes_state *state;
|
|
struct bt_mesh_last_msg_info last;
|
|
struct bt_mesh_state_transition transition;
|
|
};
|
|
|
|
struct bt_mesh_scene_setup_srv {
|
|
struct bt_mesh_model *model;
|
|
struct bt_mesh_server_rsp_ctrl rsp_ctrl;
|
|
struct bt_mesh_scenes_state *state;
|
|
};
|
|
|
|
struct schedule_register {
|
|
bool in_use;
|
|
u64_t year : 7,
|
|
month : 12,
|
|
day : 5,
|
|
hour : 5,
|
|
minute : 6,
|
|
second : 6,
|
|
day_of_week : 7,
|
|
action : 4,
|
|
trans_time : 8;
|
|
u16_t scene_number;
|
|
};
|
|
|
|
struct bt_mesh_scheduler_state {
|
|
const u8_t schedule_count;
|
|
struct schedule_register *schedules; /* Up to 16 scheduled entries */
|
|
|
|
/**
|
|
* A recommended implementation of the Scheduler should calculate the
|
|
* value of the TAI Seconds of the next scheduled event and put it in
|
|
* a queue of scheduled events sorted by time.
|
|
*
|
|
* Every second, the first event in the queue is compared with the value
|
|
* of the Time state. The first event is executed if it is less than or
|
|
* equal to the Time state and then removed from the queue. After
|
|
* execution, the Repeat Flag shall be checked, and the next occurrence
|
|
* of the scheduled event is calculated and put in the queue.
|
|
*
|
|
* One second timeout value, and compare the first event in queue with the
|
|
* Time state. If it is satisfied, then execute the first event. Also the
|
|
* Repeat Flag need to be checked, if it is set then the event needs to
|
|
* be put into the end of queue.
|
|
*
|
|
* sys_slist_t event_queue;
|
|
*
|
|
* For each event_queue item, it can use the following struct:
|
|
* struct schedule_event {
|
|
* sys_snode_t node;
|
|
* u8_t event_index;
|
|
* };
|
|
*
|
|
* Also we need a "struct k_delayed_work track_timer" which can be used to
|
|
* track the schedule timer and handle proper scheduled events.
|
|
*/
|
|
};
|
|
|
|
struct bt_mesh_scheduler_srv {
|
|
struct bt_mesh_model *model;
|
|
struct bt_mesh_server_rsp_ctrl rsp_ctrl;
|
|
struct bt_mesh_scheduler_state *state;
|
|
};
|
|
|
|
struct bt_mesh_scheduler_setup_srv {
|
|
struct bt_mesh_model *model;
|
|
struct bt_mesh_server_rsp_ctrl rsp_ctrl;
|
|
struct bt_mesh_scheduler_state *state;
|
|
};
|
|
|
|
typedef union {
|
|
struct {
|
|
u8_t tai_seconds[5];
|
|
u8_t subsecond;
|
|
u8_t uncertainty;
|
|
u16_t time_authority : 1;
|
|
u16_t tai_utc_delta_curr : 15;
|
|
u8_t time_zone_offset_curr;
|
|
} time_set;
|
|
struct {
|
|
u8_t tai_seconds[5];
|
|
u8_t subsecond;
|
|
u8_t uncertainty;
|
|
u16_t time_authority : 1;
|
|
u16_t tai_utc_delta_curr : 15;
|
|
u8_t time_zone_offset_curr;
|
|
} time_status;
|
|
struct {
|
|
u8_t time_zone_offset_new;
|
|
u8_t tai_zone_change[5];
|
|
} time_zone_set;
|
|
struct {
|
|
u16_t tai_utc_delta_new : 15;
|
|
u8_t tai_delta_change[5];
|
|
} tai_utc_delta_set;
|
|
struct {
|
|
u8_t role;
|
|
} time_role_set;
|
|
struct {
|
|
u16_t scene_number;
|
|
} scene_store;
|
|
struct {
|
|
u16_t scene_number;
|
|
} scene_recall;
|
|
struct {
|
|
u16_t scene_number;
|
|
} scene_delete;
|
|
struct {
|
|
u64_t index : 4,
|
|
year : 7,
|
|
month : 12,
|
|
day : 5,
|
|
hour : 5,
|
|
minute : 6,
|
|
second : 6,
|
|
day_of_week : 7,
|
|
action : 4,
|
|
trans_time : 8;
|
|
u16_t scene_number;
|
|
} scheduler_act_set;
|
|
} bt_mesh_time_scene_server_state_change_t;
|
|
|
|
typedef union {
|
|
struct {
|
|
u8_t index;
|
|
} scheduler_act_get;
|
|
} bt_mesh_time_scene_server_recv_get_msg_t;
|
|
|
|
typedef union {
|
|
struct {
|
|
u8_t tai_seconds[5];
|
|
u8_t subsecond;
|
|
u8_t uncertainty;
|
|
u16_t time_authority : 1;
|
|
u16_t tai_utc_delta : 15;
|
|
u8_t time_zone_offset;
|
|
} time_set;
|
|
struct {
|
|
u8_t time_zone_offset_new;
|
|
u8_t tai_zone_change[5];
|
|
} time_zone_set;
|
|
struct {
|
|
u16_t tai_utc_delta_new : 15;
|
|
u16_t padding : 1;
|
|
u8_t tai_delta_change[5];
|
|
} tai_utc_delta_set;
|
|
struct {
|
|
u8_t time_role;
|
|
} time_role_set;
|
|
struct {
|
|
u16_t scene_number;
|
|
} scene_store;
|
|
struct {
|
|
bool op_en;
|
|
u16_t scene_number;
|
|
u8_t tid;
|
|
u8_t trans_time;
|
|
u8_t delay;
|
|
} scene_recall;
|
|
struct {
|
|
u16_t scene_number;
|
|
} scene_delete;
|
|
struct {
|
|
u64_t index : 4,
|
|
year : 7,
|
|
month : 12,
|
|
day : 5,
|
|
hour : 5,
|
|
minute : 6,
|
|
second : 6,
|
|
day_of_week : 7,
|
|
action : 4,
|
|
trans_time : 8;
|
|
u16_t scene_number;
|
|
} scheduler_act_set;
|
|
} bt_mesh_time_scene_server_recv_set_msg_t;
|
|
|
|
typedef union {
|
|
struct {
|
|
u8_t tai_seconds[5];
|
|
u8_t subsecond;
|
|
u8_t uncertainty;
|
|
u16_t time_authority : 1;
|
|
u16_t tai_utc_delta : 15;
|
|
u8_t time_zone_offset;
|
|
} time_status;
|
|
} bt_mesh_time_scene_server_recv_status_msg_t;
|
|
|
|
void bt_mesh_time_scene_server_lock(void);
|
|
void bt_mesh_time_scene_server_unlock(void);
|
|
|
|
void scene_publish(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, u16_t opcode);
|
|
|
|
int bt_mesh_time_srv_init(struct bt_mesh_model *model, bool primary);
|
|
int bt_mesh_time_setup_srv_init(struct bt_mesh_model *model, bool primary);
|
|
int bt_mesh_scene_srv_init(struct bt_mesh_model *model, bool primary);
|
|
int bt_mesh_scene_setup_srv_init(struct bt_mesh_model *model, bool primary);
|
|
int bt_mesh_scheduler_srv_init(struct bt_mesh_model *model, bool primary);
|
|
int bt_mesh_scheduler_setup_srv_init(struct bt_mesh_model *model, bool primary);
|
|
|
|
int bt_mesh_time_srv_deinit(struct bt_mesh_model *model, bool primary);
|
|
int bt_mesh_time_setup_srv_deinit(struct bt_mesh_model *model, bool primary);
|
|
int bt_mesh_scene_srv_deinit(struct bt_mesh_model *model, bool primary);
|
|
int bt_mesh_scene_setup_srv_deinit(struct bt_mesh_model *model, bool primary);
|
|
int bt_mesh_scheduler_srv_deinit(struct bt_mesh_model *model, bool primary);
|
|
int bt_mesh_scheduler_setup_srv_deinit(struct bt_mesh_model *model, bool primary);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* _TIME_SCENE_SERVER_H_ */
|