1 /*
2 * Copyright (C) 2019 BlueKitchen GmbH
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the copyright holders nor the names of
14 * contributors may be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 * 4. Any redistribution, use, or modification is done solely for
17 * personal benefit and not for any commercial purpose or for
18 * monetary gain.
19 *
20 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BLUEKITCHEN
24 * GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 *
33 * Please inquire about commercial licensing options at
34 * [email protected]
35 *
36 */
37
38 #define BTSTACK_FILE__ "mesh_generic_level_server.c"
39
40 #include <inttypes.h>
41 #include <string.h>
42 #include <stdio.h>
43
44 #include "mesh/mesh_generic_level_server.h"
45
46 #include "bluetooth_company_id.h"
47 #include "btstack_debug.h"
48 #include "btstack_memory.h"
49 #include "btstack_util.h"
50
51 #include "mesh/mesh_access.h"
52 #include "mesh/mesh_foundation.h"
53 #include "mesh/mesh_generic_model.h"
54 #include "mesh/mesh_keys.h"
55 #include "mesh/mesh_network.h"
56 #include "mesh/mesh_upper_transport.h"
57
generic_server_send_message(uint16_t src,uint16_t dest,uint16_t netkey_index,uint16_t appkey_index,mesh_pdu_t * pdu)58 static void generic_server_send_message(uint16_t src, uint16_t dest, uint16_t netkey_index, uint16_t appkey_index, mesh_pdu_t *pdu){
59 uint8_t ttl = mesh_foundation_default_ttl_get();
60 mesh_upper_transport_setup_access_pdu_header(pdu, netkey_index, appkey_index, ttl, src, dest, 0);
61 mesh_access_send_unacknowledged_pdu(pdu);
62 }
63
64 // Transition
add_and_clip_int16(int16_t current_value,int32_t increment)65 static int16_t add_and_clip_int16(int16_t current_value, int32_t increment){
66 int32_t value = current_value + increment;
67 if (value < -32768){
68 value = -32768;
69 } else if (value > 32767){
70 value = 32767;
71 }
72 return (int16_t) value;
73 }
74
generic_level_server_get_base_transition(mesh_model_t * mesh_model)75 static mesh_transition_t * generic_level_server_get_base_transition(mesh_model_t * mesh_model) {
76 mesh_generic_level_state_t * generic_level_server_state = (mesh_generic_level_state_t *)mesh_model->model_data;
77 return &generic_level_server_state->transition_data.base_transition;
78 }
79
mesh_server_transition_handler(mesh_transition_t * base_transition,model_state_update_reason_t event)80 static void mesh_server_transition_handler(mesh_transition_t * base_transition, model_state_update_reason_t event){
81 mesh_transition_int16_t * transition = (mesh_transition_int16_t*) base_transition;
82 printf("Transition: event %x, current %x, target %x, increment %x, time %" PRIu32 "\n", (int) event, transition->current_value, transition->target_value, transition->stepwise_value_increment, btstack_run_loop_get_time_ms());
83 switch (event){
84 case MODEL_STATE_UPDATE_REASON_TRANSITION_ACTIVE:
85 transition->current_value = add_and_clip_int16(transition->current_value, transition->stepwise_value_increment);
86 mesh_access_state_changed(transition->base_transition.mesh_model);
87 break;
88 case MODEL_STATE_UPDATE_REASON_SET:
89 case MODEL_STATE_UPDATE_REASON_TRANSITION_END:
90 transition->current_value = transition->target_value;
91 mesh_access_state_changed(transition->base_transition.mesh_model);
92 break;
93 case MODEL_STATE_UPDATE_REASON_TRANSITION_ABORT:
94 break;
95 default:
96 break;
97 }
98
99 // notify app
100 mesh_model_t * generic_level_server_model = transition->base_transition.mesh_model;
101 mesh_access_emit_state_update_int16(generic_level_server_model->model_packet_handler,
102 mesh_access_get_element_index(generic_level_server_model),
103 generic_level_server_model->model_identifier,
104 MODEL_STATE_ID_GENERIC_LEVEL,
105 event,
106 transition->current_value);
107 }
108
mesh_server_transition_setup_transition_or_instantaneous_update_int16(mesh_model_t * mesh_model,uint8_t transition_time_gdtt,uint8_t delay_time_gdtt,uint32_t delta_value)109 static void mesh_server_transition_setup_transition_or_instantaneous_update_int16(mesh_model_t *mesh_model, uint8_t transition_time_gdtt, uint8_t delay_time_gdtt, uint32_t delta_value){
110 mesh_generic_level_state_t * generic_level_server_state = (mesh_generic_level_state_t *)mesh_model->model_data;
111 mesh_transition_t * transition = &generic_level_server_state->transition_data.base_transition;
112
113 // calc step increment
114 int num_steps = mesh_access_transitions_num_steps_from_gdtt(transition_time_gdtt);
115 if (num_steps > 0){
116 generic_level_server_state->transition_data.stepwise_value_increment = delta_value / num_steps;
117 } else {
118 generic_level_server_state->transition_data.stepwise_value_increment = 0;
119 }
120
121 mesh_access_transition_setup(mesh_model, transition, transition_time_gdtt, delay_time_gdtt, &mesh_server_transition_handler);
122 }
123
124 // Generic Level State
125
mesh_generic_level_server_register_packet_handler(mesh_model_t * generic_level_server_model,btstack_packet_handler_t transition_events_packet_handler)126 void mesh_generic_level_server_register_packet_handler(mesh_model_t *generic_level_server_model, btstack_packet_handler_t transition_events_packet_handler){
127 btstack_assert(generic_level_server_model != NULL);
128 btstack_assert(transition_events_packet_handler != NULL);
129 generic_level_server_model->model_packet_handler = transition_events_packet_handler;
130 }
131
132 const mesh_access_message_t mesh_generic_level_status_transition = {
133 MESH_GENERIC_LEVEL_STATUS, "221"
134 };
135
136 const mesh_access_message_t mesh_generic_level_status_instantaneous = {
137 MESH_GENERIC_LEVEL_STATUS, "2"
138 };
139
mesh_generic_level_status_message(mesh_model_t * generic_level_server_model)140 static mesh_pdu_t * mesh_generic_level_status_message(mesh_model_t *generic_level_server_model){
141 mesh_generic_level_state_t * state = (mesh_generic_level_state_t *) generic_level_server_model->model_data;
142 btstack_assert(state != NULL);
143
144 // setup message
145 mesh_upper_transport_pdu_t * transport_pdu = NULL;
146 if (state->transition_data.base_transition.num_steps > 0) {
147 uint8_t remaining_time = (((uint8_t)state->transition_data.base_transition.step_resolution) << 6) | (state->transition_data.base_transition.num_steps);
148 transport_pdu = mesh_access_setup_message(&mesh_generic_level_status_transition, state->transition_data.current_value,
149 state->transition_data.target_value, remaining_time);
150 } else {
151 transport_pdu = mesh_access_setup_message(&mesh_generic_level_status_instantaneous, state->transition_data.current_value);
152 }
153 return (mesh_pdu_t *)transport_pdu;
154 }
155
generic_level_handle_set_target_level_message(mesh_model_t * mesh_model,mesh_pdu_t * pdu)156 static void generic_level_handle_set_target_level_message(mesh_model_t *mesh_model, mesh_pdu_t * pdu){
157 mesh_generic_level_state_t * generic_level_server_state = (mesh_generic_level_state_t *)mesh_model->model_data;
158 btstack_assert(generic_level_server_state != NULL);
159
160 mesh_access_parser_state_t parser;
161 mesh_access_parser_init(&parser, (mesh_pdu_t*) pdu);
162 int16_t level_value = (int16_t) mesh_access_parser_get_uint16(&parser);
163 // The TID field is a transaction identifier indicating whether the message is
164 // a new message or a retransmission of a previously sent message
165 uint8_t tid = mesh_access_parser_get_uint8(&parser);
166
167 uint8_t transition_time_gdtt = 0;
168 uint8_t delay_time_gdtt = 0;
169 if (mesh_access_parser_available(&parser) == 2){
170 // Generic Default Transition Time format - num_steps (higher 6 bits), step_resolution (lower 2 bits)
171 transition_time_gdtt = mesh_access_parser_get_uint8(&parser);
172 delay_time_gdtt = mesh_access_parser_get_uint8(&parser);
173 }
174
175 mesh_transition_t * base_transition = generic_level_server_get_base_transition(mesh_model);
176
177 switch (mesh_access_transitions_transaction_status(base_transition, tid, mesh_pdu_src(pdu), mesh_pdu_dst(pdu))){
178 case MESH_TRANSACTION_STATUS_RETRANSMISSION:
179 // ignore
180 break;
181 default:
182 mesh_access_transitions_init_transaction(base_transition, tid, mesh_pdu_src(pdu), mesh_pdu_dst(pdu));
183
184 generic_level_server_state->transition_data.initial_value = generic_level_server_state->transition_data.current_value;
185 generic_level_server_state->transition_data.target_value = level_value;
186
187 int32_t delta_value = level_value - generic_level_server_state->transition_data.current_value;
188 mesh_server_transition_setup_transition_or_instantaneous_update_int16(mesh_model, transition_time_gdtt, delay_time_gdtt, delta_value);
189 mesh_access_state_changed(mesh_model);
190 break;
191 }
192
193 }
194
generic_level_handle_set_delta_message(mesh_model_t * mesh_model,mesh_pdu_t * pdu)195 static void generic_level_handle_set_delta_message(mesh_model_t *mesh_model, mesh_pdu_t * pdu){
196 mesh_generic_level_state_t * generic_level_server_state = (mesh_generic_level_state_t *)mesh_model->model_data;
197 btstack_assert(generic_level_server_state != NULL);
198
199 mesh_access_parser_state_t parser;
200 mesh_access_parser_init(&parser, (mesh_pdu_t*) pdu);
201 int32_t delta_value = mesh_access_parser_get_uint32(&parser);
202
203 // The TID field is a transaction identifier indicating whether the message is
204 // a new message or a retransmission of a previously sent message
205 uint8_t tid = mesh_access_parser_get_uint8(&parser);
206
207 uint8_t transition_time_gdtt = 0;
208 uint8_t delay_time_gdtt = 0;
209 if (mesh_access_parser_available(&parser) == 2){
210 // Generic Default Transition Time format - num_steps (higher 6 bits), step_resolution (lower 2 bits)
211 transition_time_gdtt = mesh_access_parser_get_uint8(&parser);
212 delay_time_gdtt = mesh_access_parser_get_uint8(&parser);
213 }
214
215 mesh_transition_t * base_transition = generic_level_server_get_base_transition(mesh_model);
216
217 switch (mesh_access_transitions_transaction_status(base_transition, tid, mesh_pdu_src(pdu), mesh_pdu_dst(pdu))){
218 case MESH_TRANSACTION_STATUS_DIFFERENT_DST_OR_SRC:
219 // abort transaction
220 printf("Transaction abort\n");
221 mesh_access_transitions_abort_transaction(base_transition);
222 generic_level_server_state->transition_data.current_value = generic_level_server_state->transition_data.initial_value;
223 mesh_server_transition_setup_transition_or_instantaneous_update_int16(mesh_model, 0, 0, 0);
224 break;
225 case MESH_TRANSACTION_STATUS_NEW:
226 // start transaction with current value
227 mesh_access_transitions_init_transaction(base_transition, tid, mesh_pdu_src(pdu), mesh_pdu_dst(pdu));
228 generic_level_server_state->transition_data.initial_value = generic_level_server_state->transition_data.current_value;
229 generic_level_server_state->transition_data.target_value = add_and_clip_int16(generic_level_server_state->transition_data.initial_value, delta_value);
230 printf("Transaction %u, new, init %x, target %x\n", tid, generic_level_server_state->transition_data.initial_value, generic_level_server_state->transition_data.target_value);
231 mesh_server_transition_setup_transition_or_instantaneous_update_int16(mesh_model, transition_time_gdtt, delay_time_gdtt, delta_value);
232 mesh_access_state_changed(mesh_model);
233 break;
234 case MESH_TRANSACTION_STATUS_RETRANSMISSION:
235 // replace last delta message
236 mesh_access_transitions_init_transaction(base_transition, tid, mesh_pdu_src(pdu), mesh_pdu_dst(pdu));
237 generic_level_server_state->transition_data.target_value = add_and_clip_int16(generic_level_server_state->transition_data.initial_value, delta_value);
238 printf("Transaction %u, retransmission, init %x, target %x\n", tid, generic_level_server_state->transition_data.initial_value, generic_level_server_state->transition_data.target_value);
239 mesh_server_transition_setup_transition_or_instantaneous_update_int16(mesh_model, transition_time_gdtt, delay_time_gdtt, delta_value);
240 mesh_access_state_changed(mesh_model);
241 break;
242 default:
243 break;
244 }
245 }
246
generic_level_handle_set_move_message(mesh_model_t * mesh_model,mesh_pdu_t * pdu)247 static void generic_level_handle_set_move_message(mesh_model_t *mesh_model, mesh_pdu_t * pdu){
248 mesh_generic_level_state_t * generic_level_server_state = (mesh_generic_level_state_t *)mesh_model->model_data;
249 btstack_assert(generic_level_server_state != NULL);
250
251 mesh_access_parser_state_t parser;
252 mesh_access_parser_init(&parser, (mesh_pdu_t*) pdu);
253 int32_t delta_value = (int32_t) mesh_access_parser_get_uint16(&parser);
254
255 // The TID field is a transaction identifier indicating whether the message is
256 // a new message or a retransmission of a previously sent message
257 uint8_t tid = mesh_access_parser_get_uint8(&parser);
258
259 uint8_t transition_time_gdtt = 0;
260 uint8_t delay_time_gdtt = 0;
261 if (mesh_access_parser_available(&parser) == 2){
262 // Generic Default Transition Time format - num_steps (higher 6 bits), step_resolution (lower 2 bits)
263 transition_time_gdtt = mesh_access_parser_get_uint8(&parser);
264 delay_time_gdtt = mesh_access_parser_get_uint8(&parser);
265 } else {
266 // transition speed is delta / num steps, without num steps, and without a default transition time, we cannot do this
267 return;
268 }
269
270 mesh_transition_t * base_transition = generic_level_server_get_base_transition(mesh_model);
271
272 switch (mesh_access_transitions_transaction_status(base_transition, tid, mesh_pdu_src(pdu), mesh_pdu_dst(pdu))){
273 case MESH_TRANSACTION_STATUS_RETRANSMISSION:
274 // ignore retransmission
275 break;
276 default:
277 mesh_access_transitions_init_transaction(base_transition, tid, mesh_pdu_src(pdu), mesh_pdu_dst(pdu));
278
279 generic_level_server_state->transition_data.initial_value = generic_level_server_state->transition_data.current_value;
280 generic_level_server_state->transition_data.target_value = add_and_clip_int16(generic_level_server_state->transition_data.current_value, delta_value);
281 if (delta_value > 0){
282 generic_level_server_state->transition_data.target_value = 32767;
283 } else {
284 generic_level_server_state->transition_data.target_value = -32768;
285 }
286
287 mesh_server_transition_setup_transition_or_instantaneous_update_int16(mesh_model, transition_time_gdtt, delay_time_gdtt, delta_value);
288 generic_level_server_state->transition_data.base_transition.num_steps = MESH_TRANSITION_NUM_STEPS_INFINITE;
289 break;
290 }
291 }
292
generic_level_get_handler(mesh_model_t * generic_level_server_model,mesh_pdu_t * pdu)293 static void generic_level_get_handler(mesh_model_t *generic_level_server_model, mesh_pdu_t * pdu){
294 mesh_upper_transport_pdu_t * transport_pdu = (mesh_upper_transport_pdu_t *) mesh_generic_level_status_message(generic_level_server_model);
295 if (transport_pdu != NULL) {
296 generic_server_send_message(mesh_access_get_element_address(generic_level_server_model), mesh_pdu_src(pdu), mesh_pdu_netkey_index(pdu), mesh_pdu_appkey_index(pdu), (mesh_pdu_t *) transport_pdu);
297 }
298 mesh_access_message_processed(pdu);
299 }
300
generic_level_set_handler(mesh_model_t * generic_level_server_model,mesh_pdu_t * pdu)301 static void generic_level_set_handler(mesh_model_t *generic_level_server_model, mesh_pdu_t * pdu){
302 generic_level_handle_set_target_level_message(generic_level_server_model, pdu);
303
304 mesh_upper_transport_pdu_t * transport_pdu = (mesh_upper_transport_pdu_t *) mesh_generic_level_status_message(generic_level_server_model);
305 if (transport_pdu != NULL) {
306 generic_server_send_message(mesh_access_get_element_address(generic_level_server_model), mesh_pdu_src(pdu), mesh_pdu_netkey_index(pdu), mesh_pdu_appkey_index(pdu), (mesh_pdu_t *) transport_pdu);
307 }
308 mesh_access_message_processed(pdu);
309 }
310
generic_level_set_unacknowledged_handler(mesh_model_t * generic_level_server_model,mesh_pdu_t * pdu)311 static void generic_level_set_unacknowledged_handler(mesh_model_t *generic_level_server_model, mesh_pdu_t * pdu){
312 generic_level_handle_set_target_level_message(generic_level_server_model, pdu);
313 mesh_access_message_processed(pdu);
314 }
315
generic_delta_set_handler(mesh_model_t * generic_level_server_model,mesh_pdu_t * pdu)316 static void generic_delta_set_handler(mesh_model_t *generic_level_server_model, mesh_pdu_t * pdu){
317 generic_level_handle_set_delta_message(generic_level_server_model, pdu);
318
319 mesh_upper_transport_pdu_t * transport_pdu = (mesh_upper_transport_pdu_t *) mesh_generic_level_status_message(generic_level_server_model);
320 if (transport_pdu != NULL) {
321 generic_server_send_message(mesh_access_get_element_address(generic_level_server_model), mesh_pdu_src(pdu), mesh_pdu_netkey_index(pdu), mesh_pdu_appkey_index(pdu), (mesh_pdu_t *) transport_pdu);
322 }
323 mesh_access_message_processed(pdu);
324 }
325
generic_delta_set_unacknowledged_handler(mesh_model_t * generic_level_server_model,mesh_pdu_t * pdu)326 static void generic_delta_set_unacknowledged_handler(mesh_model_t *generic_level_server_model, mesh_pdu_t * pdu){
327 generic_level_handle_set_delta_message(generic_level_server_model, pdu);
328 mesh_access_message_processed(pdu);
329 }
330
generic_move_get_handler(mesh_model_t * generic_level_server_model,mesh_pdu_t * pdu)331 static void generic_move_get_handler(mesh_model_t *generic_level_server_model, mesh_pdu_t * pdu){
332 generic_level_handle_set_move_message(generic_level_server_model, pdu);
333
334 mesh_upper_transport_pdu_t * transport_pdu = (mesh_upper_transport_pdu_t *) mesh_generic_level_status_message(generic_level_server_model);
335 if (transport_pdu != NULL) {
336 generic_server_send_message(mesh_access_get_element_address(generic_level_server_model), mesh_pdu_src(pdu), mesh_pdu_netkey_index(pdu), mesh_pdu_appkey_index(pdu), (mesh_pdu_t *) transport_pdu);
337 }
338 mesh_access_message_processed(pdu);
339 }
340
generic_move_set_unacknowledged_handler(mesh_model_t * generic_level_server_model,mesh_pdu_t * pdu)341 static void generic_move_set_unacknowledged_handler(mesh_model_t *generic_level_server_model, mesh_pdu_t * pdu){
342 generic_level_handle_set_move_message(generic_level_server_model, pdu);
343 mesh_access_message_processed(pdu);
344 }
345
346 // Generic On Off Message
347 static const mesh_operation_t mesh_generic_level_model_operations[] = {
348 { MESH_GENERIC_LEVEL_GET, 0, generic_level_get_handler },
349 { MESH_GENERIC_LEVEL_SET, 3, generic_level_set_handler },
350 { MESH_GENERIC_LEVEL_SET_UNACKNOWLEDGED, 3, generic_level_set_unacknowledged_handler },
351 { MESH_GENERIC_DELTA_SET, 3, generic_delta_set_handler },
352 { MESH_GENERIC_DELTA_SET_UNACKNOWLEDGED, 3, generic_delta_set_unacknowledged_handler },
353 { MESH_GENERIC_MOVE_SET, 3, generic_move_get_handler },
354 { MESH_GENERIC_MOVE_SET_UNACKNOWLEDGED, 3, generic_move_set_unacknowledged_handler },
355 { 0, 0, NULL }
356 };
357
mesh_generic_level_server_get_operations(void)358 const mesh_operation_t * mesh_generic_level_server_get_operations(void){
359 return mesh_generic_level_model_operations;
360 }
361
mesh_generic_level_server_set_publication_model(mesh_model_t * generic_level_server_model,mesh_publication_model_t * publication_model)362 void mesh_generic_level_server_set_publication_model(mesh_model_t *generic_level_server_model, mesh_publication_model_t * publication_model){
363 if (generic_level_server_model == NULL) return;
364 if (publication_model == NULL) return;
365 publication_model->publish_state_fn = &mesh_generic_level_status_message;
366 generic_level_server_model->publication_model = publication_model;
367 }
368