xref: /btstack/src/mesh/mesh_generic_level_server.c (revision 7cdc89a533ca236b2c2564b759993b788bae89d3) 
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 MATTHIAS
24  * RINGWALD 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 <string.h>
41 #include <stdio.h>
42 
43 #include "mesh/mesh_generic_level_server.h"
44 
45 #include "bluetooth_company_id.h"
46 #include "btstack_debug.h"
47 #include "btstack_memory.h"
48 #include "btstack_util.h"
49 
50 #include "mesh/mesh_access.h"
51 #include "mesh/mesh_foundation.h"
52 #include "mesh/mesh_generic_model.h"
53 #include "mesh/mesh_keys.h"
54 #include "mesh/mesh_network.h"
55 #include "mesh/mesh_upper_transport.h"
56 
57 static void generic_server_send_message(uint16_t src, uint16_t dest, uint16_t netkey_index, uint16_t appkey_index, mesh_pdu_t *pdu){
58     uint8_t  ttl  = mesh_foundation_default_ttl_get();
59     mesh_upper_transport_setup_access_pdu_header(pdu, netkey_index, appkey_index, ttl, src, dest, 0);
60     mesh_access_send_unacknowledged_pdu(pdu);
61 }
62 
63 // Transition
64 static int16_t add_and_clip_int16(int16_t current_value, int32_t increment){
65     int32_t value = current_value + increment;
66     if (value < -32768){
67         value = -32768;
68     } else if (value > 32767){
69         value = 32767;
70     }
71    return (int16_t) value;
72 }
73 
74 static mesh_transition_t * generic_level_server_get_base_transition(mesh_model_t * mesh_model) {
75      mesh_generic_level_state_t * generic_level_server_state = (mesh_generic_level_state_t *)mesh_model->model_data;
76     return &generic_level_server_state->transition_data.base_transition;
77 }
78 
79 static void mesh_server_transition_handler(mesh_transition_t * base_transition, model_state_update_reason_t event){
80     mesh_transition_int16_t * transition = (mesh_transition_int16_t*) base_transition;
81     printf("Transition: event %x, current %x, target %x, increment %x, time %u\n", (int) event, transition->current_value, transition->target_value, transition->stepwise_value_increment, btstack_run_loop_get_time_ms());
82     switch (event){
83         case MODEL_STATE_UPDATE_REASON_TRANSITION_ACTIVE:
84             transition->current_value = add_and_clip_int16(transition->current_value, transition->stepwise_value_increment);
85             mesh_access_state_changed(transition->base_transition.mesh_model);
86             break;
87         case MODEL_STATE_UPDATE_REASON_SET:
88         case MODEL_STATE_UPDATE_REASON_TRANSITION_END:
89             transition->current_value = transition->target_value;
90             mesh_access_state_changed(transition->base_transition.mesh_model);
91             break;
92         case MODEL_STATE_UPDATE_REASON_TRANSITION_ABORT:
93             break;
94         default:
95             break;
96     }
97 
98     // notify app
99     mesh_model_t * generic_level_server_model = transition->base_transition.mesh_model;
100     mesh_access_emit_state_update_int16(generic_level_server_model->model_packet_handler,
101         mesh_access_get_element_index(generic_level_server_model),
102         generic_level_server_model->model_identifier,
103         MODEL_STATE_ID_GENERIC_LEVEL,
104         event,
105         transition->current_value);
106 }
107 
108 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){
109     mesh_generic_level_state_t * generic_level_server_state = (mesh_generic_level_state_t *)mesh_model->model_data;
110     mesh_transition_t * transition = &generic_level_server_state->transition_data.base_transition;
111 
112     // calc step increment
113     int num_steps = mesh_access_transitions_num_steps_from_gdtt(transition_time_gdtt);
114     if (num_steps > 0){
115         generic_level_server_state->transition_data.stepwise_value_increment = delta_value / num_steps;
116     } else {
117         generic_level_server_state->transition_data.stepwise_value_increment = 0;
118     }
119 
120     mesh_access_transition_setup(mesh_model, transition, transition_time_gdtt, delay_time_gdtt, &mesh_server_transition_handler);
121 }
122 
123 // Generic Level State
124 
125 void mesh_generic_level_server_register_packet_handler(mesh_model_t *generic_level_server_model, btstack_packet_handler_t transition_events_packet_handler){
126     btstack_assert(generic_level_server_model != NULL);
127     btstack_assert(transition_events_packet_handler != NULL);
128     generic_level_server_model->model_packet_handler = transition_events_packet_handler;
129 }
130 
131 const mesh_access_message_t mesh_generic_level_status_transition = {
132         MESH_GENERIC_LEVEL_STATUS, "221"
133 };
134 
135 const mesh_access_message_t mesh_generic_level_status_instantaneous = {
136         MESH_GENERIC_LEVEL_STATUS, "2"
137 };
138 
139 static mesh_pdu_t * mesh_generic_level_status_message(mesh_model_t *generic_level_server_model){
140     mesh_generic_level_state_t * state = (mesh_generic_level_state_t *) generic_level_server_model->model_data;
141     btstack_assert(state != NULL);
142 
143     // setup message
144     mesh_transport_pdu_t * transport_pdu = NULL;
145     if (state->transition_data.base_transition.num_steps > 0) {
146         uint8_t remaining_time = (((uint8_t)state->transition_data.base_transition.step_resolution) << 6) | (state->transition_data.base_transition.num_steps);
147         transport_pdu = mesh_access_setup_segmented_message(&mesh_generic_level_status_transition, state->transition_data.current_value,
148             state->transition_data.target_value, remaining_time);
149     } else {
150         transport_pdu = mesh_access_setup_segmented_message(&mesh_generic_level_status_instantaneous, state->transition_data.current_value);
151     }
152     return (mesh_pdu_t *)transport_pdu;
153 }
154 
155 static void generic_level_handle_set_target_level_message(mesh_model_t *mesh_model, mesh_pdu_t * pdu){
156     mesh_generic_level_state_t * generic_level_server_state = (mesh_generic_level_state_t *)mesh_model->model_data;
157     btstack_assert(generic_level_server_state != NULL);
158 
159     mesh_access_parser_state_t parser;
160     mesh_access_parser_init(&parser, (mesh_pdu_t*) pdu);
161     int16_t level_value = (int16_t)mesh_access_parser_get_u16(&parser);
162     // The TID field is a transaction identifier indicating whether the message is
163     // a new message or a retransmission of a previously sent message
164     uint8_t tid = mesh_access_parser_get_u8(&parser);
165 
166     uint8_t transition_time_gdtt = 0;
167     uint8_t delay_time_gdtt = 0;
168     if (mesh_access_parser_available(&parser) == 2){
169         //  Generic Default Transition Time format - num_steps (higher 6 bits), step_resolution (lower 2 bits)
170         transition_time_gdtt = mesh_access_parser_get_u8(&parser);
171         delay_time_gdtt = mesh_access_parser_get_u8(&parser);
172     }
173 
174     mesh_transition_t * base_transition = generic_level_server_get_base_transition(mesh_model);
175 
176     switch (mesh_access_transitions_transaction_status(base_transition, tid, mesh_pdu_src(pdu), mesh_pdu_dst(pdu))){
177         case MESH_TRANSACTION_STATUS_RETRANSMISSION:
178             // ignore
179             break;
180         default:
181             mesh_access_transitions_init_transaction(base_transition, tid, mesh_pdu_src(pdu), mesh_pdu_dst(pdu));
182 
183             generic_level_server_state->transition_data.initial_value = generic_level_server_state->transition_data.current_value;
184             generic_level_server_state->transition_data.target_value = level_value;
185 
186             int32_t delta_value = level_value - generic_level_server_state->transition_data.current_value;
187             mesh_server_transition_setup_transition_or_instantaneous_update_int16(mesh_model, transition_time_gdtt, delay_time_gdtt, delta_value);
188             mesh_access_state_changed(mesh_model);
189             break;
190     }
191 
192 }
193 
194 static void generic_level_handle_set_delta_message(mesh_model_t *mesh_model, mesh_pdu_t * pdu){
195     mesh_generic_level_state_t * generic_level_server_state = (mesh_generic_level_state_t *)mesh_model->model_data;
196     btstack_assert(generic_level_server_state != NULL);
197 
198     mesh_access_parser_state_t parser;
199     mesh_access_parser_init(&parser, (mesh_pdu_t*) pdu);
200     int32_t delta_value = mesh_access_parser_get_u32(&parser);
201 
202     // The TID field is a transaction identifier indicating whether the message is
203     // a new message or a retransmission of a previously sent message
204     uint8_t tid = mesh_access_parser_get_u8(&parser);
205 
206     uint8_t transition_time_gdtt = 0;
207     uint8_t delay_time_gdtt = 0;
208     if (mesh_access_parser_available(&parser) == 2){
209         //  Generic Default Transition Time format - num_steps (higher 6 bits), step_resolution (lower 2 bits)
210         transition_time_gdtt = mesh_access_parser_get_u8(&parser);
211         delay_time_gdtt = mesh_access_parser_get_u8(&parser);
212     }
213 
214     mesh_transition_t * base_transition = generic_level_server_get_base_transition(mesh_model);
215 
216     switch (mesh_access_transitions_transaction_status(base_transition, tid, mesh_pdu_src(pdu), mesh_pdu_dst(pdu))){
217         case MESH_TRANSACTION_STATUS_DIFFERENT_DST_OR_SRC:
218             // abort transaction
219             printf("Transaction abort\n");
220             mesh_access_transitions_abort_transaction(base_transition);
221             generic_level_server_state->transition_data.current_value = generic_level_server_state->transition_data.initial_value;
222             mesh_server_transition_setup_transition_or_instantaneous_update_int16(mesh_model, 0, 0, 0);
223             break;
224         case MESH_TRANSACTION_STATUS_NEW:
225             // start transaction with current value
226             mesh_access_transitions_init_transaction(base_transition, tid, mesh_pdu_src(pdu), mesh_pdu_dst(pdu));
227             generic_level_server_state->transition_data.initial_value = generic_level_server_state->transition_data.current_value;
228             generic_level_server_state->transition_data.target_value = add_and_clip_int16(generic_level_server_state->transition_data.initial_value, delta_value);
229             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);
230             mesh_server_transition_setup_transition_or_instantaneous_update_int16(mesh_model, transition_time_gdtt, delay_time_gdtt, delta_value);
231             mesh_access_state_changed(mesh_model);
232             break;
233         case MESH_TRANSACTION_STATUS_RETRANSMISSION:
234             // replace last delta message
235             mesh_access_transitions_init_transaction(base_transition, tid, mesh_pdu_src(pdu), mesh_pdu_dst(pdu));
236             generic_level_server_state->transition_data.target_value = add_and_clip_int16(generic_level_server_state->transition_data.initial_value, delta_value);
237             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);
238             mesh_server_transition_setup_transition_or_instantaneous_update_int16(mesh_model, transition_time_gdtt, delay_time_gdtt, delta_value);
239             mesh_access_state_changed(mesh_model);
240             break;
241         default:
242             break;
243     }
244 }
245 
246 static void generic_level_handle_set_move_message(mesh_model_t *mesh_model, mesh_pdu_t * pdu){
247     mesh_generic_level_state_t * generic_level_server_state = (mesh_generic_level_state_t *)mesh_model->model_data;
248     btstack_assert(generic_level_server_state != NULL);
249 
250     mesh_access_parser_state_t parser;
251     mesh_access_parser_init(&parser, (mesh_pdu_t*) pdu);
252     int32_t delta_value = (int32_t) mesh_access_parser_get_u16(&parser);
253 
254     // The TID field is a transaction identifier indicating whether the message is
255     // a new message or a retransmission of a previously sent message
256     uint8_t tid = mesh_access_parser_get_u8(&parser);
257 
258     uint8_t transition_time_gdtt = 0;
259     uint8_t delay_time_gdtt = 0;
260     if (mesh_access_parser_available(&parser) == 2){
261         //  Generic Default Transition Time format - num_steps (higher 6 bits), step_resolution (lower 2 bits)
262         transition_time_gdtt = mesh_access_parser_get_u8(&parser);
263         delay_time_gdtt = mesh_access_parser_get_u8(&parser);
264     } else {
265         // transition speed is delta / num steps, without num steps, and without a default transition time, we cannot do this
266         return;
267     }
268 
269     mesh_transition_t * base_transition = generic_level_server_get_base_transition(mesh_model);
270 
271     switch (mesh_access_transitions_transaction_status(base_transition, tid, mesh_pdu_src(pdu), mesh_pdu_dst(pdu))){
272         case MESH_TRANSACTION_STATUS_RETRANSMISSION:
273             // ignore retransmission
274             break;
275         default:
276             mesh_access_transitions_init_transaction(base_transition, tid, mesh_pdu_src(pdu), mesh_pdu_dst(pdu));
277 
278             generic_level_server_state->transition_data.initial_value = generic_level_server_state->transition_data.current_value;
279             generic_level_server_state->transition_data.target_value = add_and_clip_int16(generic_level_server_state->transition_data.current_value, delta_value);
280             if (delta_value > 0){
281                 generic_level_server_state->transition_data.target_value = 32767;
282             } else {
283                 generic_level_server_state->transition_data.target_value = -32768;
284             }
285 
286             mesh_server_transition_setup_transition_or_instantaneous_update_int16(mesh_model, transition_time_gdtt, delay_time_gdtt, delta_value);
287             generic_level_server_state->transition_data.base_transition.num_steps = MESH_TRANSITION_NUM_STEPS_INFINITE;
288             break;
289     }
290 }
291 
292 static void generic_level_get_handler(mesh_model_t *generic_level_server_model, mesh_pdu_t * pdu){
293     mesh_transport_pdu_t * transport_pdu = (mesh_transport_pdu_t *) mesh_generic_level_status_message(generic_level_server_model);
294     if (transport_pdu != NULL) {
295         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);
296     }
297     mesh_access_message_processed(pdu);
298 }
299 
300 static void generic_level_set_handler(mesh_model_t *generic_level_server_model, mesh_pdu_t * pdu){
301     generic_level_handle_set_target_level_message(generic_level_server_model, pdu);
302 
303     mesh_transport_pdu_t * transport_pdu = (mesh_transport_pdu_t *) mesh_generic_level_status_message(generic_level_server_model);
304     if (transport_pdu != NULL) {
305         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);
306     }
307     mesh_access_message_processed(pdu);
308 }
309 
310 static void generic_level_set_unacknowledged_handler(mesh_model_t *generic_level_server_model, mesh_pdu_t * pdu){
311     generic_level_handle_set_target_level_message(generic_level_server_model, pdu);
312     mesh_access_message_processed(pdu);
313 }
314 
315 static void generic_delta_set_handler(mesh_model_t *generic_level_server_model, mesh_pdu_t * pdu){
316     generic_level_handle_set_delta_message(generic_level_server_model, pdu);
317 
318     mesh_transport_pdu_t * transport_pdu = (mesh_transport_pdu_t *) mesh_generic_level_status_message(generic_level_server_model);
319     if (transport_pdu != NULL) {
320         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);
321     }
322     mesh_access_message_processed(pdu);
323 }
324 
325 static void generic_delta_set_unacknowledged_handler(mesh_model_t *generic_level_server_model, mesh_pdu_t * pdu){
326     generic_level_handle_set_delta_message(generic_level_server_model, pdu);
327     mesh_access_message_processed(pdu);
328 }
329 
330 static void generic_move_get_handler(mesh_model_t *generic_level_server_model, mesh_pdu_t * pdu){
331     generic_level_handle_set_move_message(generic_level_server_model, pdu);
332 
333     mesh_transport_pdu_t * transport_pdu = (mesh_transport_pdu_t *) mesh_generic_level_status_message(generic_level_server_model);
334     if (transport_pdu != NULL) {
335         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);
336     }
337     mesh_access_message_processed(pdu);
338 }
339 
340 static void generic_move_set_unacknowledged_handler(mesh_model_t *generic_level_server_model, mesh_pdu_t * pdu){
341     generic_level_handle_set_move_message(generic_level_server_model, pdu);
342     mesh_access_message_processed(pdu);
343 }
344 
345 // Generic On Off Message
346 const static mesh_operation_t mesh_generic_level_model_operations[] = {
347     { MESH_GENERIC_LEVEL_GET,                                   0, generic_level_get_handler },
348     { MESH_GENERIC_LEVEL_SET,                                   3, generic_level_set_handler },
349     { MESH_GENERIC_LEVEL_SET_UNACKNOWLEDGED,                    3, generic_level_set_unacknowledged_handler },
350     { MESH_GENERIC_DELTA_SET,                                   3, generic_delta_set_handler },
351     { MESH_GENERIC_DELTA_SET_UNACKNOWLEDGED,                    3, generic_delta_set_unacknowledged_handler },
352     { MESH_GENERIC_MOVE_SET,                                    3, generic_move_get_handler },
353     { MESH_GENERIC_MOVE_SET_UNACKNOWLEDGED,                     3, generic_move_set_unacknowledged_handler },
354     { 0, 0, NULL }
355 };
356 
357 const mesh_operation_t * mesh_generic_level_server_get_operations(void){
358     return mesh_generic_level_model_operations;
359 }
360 
361 void mesh_generic_level_server_set_publication_model(mesh_model_t *generic_level_server_model, mesh_publication_model_t * publication_model){
362     if (generic_level_server_model == NULL) return;
363     if (publication_model == NULL) return;
364     publication_model->publish_state_fn = &mesh_generic_level_status_message;
365     generic_level_server_model->publication_model = publication_model;
366 }
367