after implementing some changes on the client and server examples i could compile my algorithm for the client but in the server i still have some problems which i didn't find the solution
all generic onoff callbacks with simple on off callbacks and modified the simple onoff structures like the generic onoff a little and in the final i want to make a model that sends String or an array of char in the mesh network .
/* Copyright (c) 2010 - 2018, Nordic Semiconductor ASA
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "app_onoff.h"
#include <stdint.h>
#include "sdk_config.h"
#include "example_common.h"
#include "simple_on_off_server.h"
#include "log.h"
#include "app_timer.h"
/** This sample implementation shows how model behaviour requirements of Generic OnOff server can
* be implemented.
*/
/* Forward declaration */
static void simple_onoff_state_get_cb(const simple_on_off_server_t * p_self);
static void simple_onoff_state_set_cb(const simple_on_off_server_t * p_self, bool on_off);
const simple_onoff_server_callbacks_t onoff_srv_cbs =
{
.onoff_cbs.set_cb = simple_onoff_state_set_cb,
.onoff_cbs.get_cb = simple_onoff_state_get_cb
};
static void onoff_state_process_timing(app_onoff_server_t * p_server)
{
uint32_t status = NRF_SUCCESS;
(void) app_timer_stop(*p_server->p_timer_id);
/* Process timing requirements */
if (p_server->state.delay_ms != 0)
{
status = app_timer_start(*p_server->p_timer_id, APP_TIMER_TICKS(p_server->state.delay_ms), p_server);
}
else if (p_server->state.remaining_time_ms != 0)
{
/* Note: We cannot use the full length of the app_timer, since RTC counter is 24 bit, and
application needs to report the remaining time whenever GET message is received in the
middle of the transition. Correctness of the reported value is limited to 100 ms at the
highest resolution as defined in section 3.1.3 of Mesh Model Specification v1.0 */
uint32_t app_timer_ticks = APP_TIMER_TICKS(p_server->state.remaining_time_ms);
if (app_timer_ticks > APP_TIMER_MAX_CNT_VAL)
{
status = app_timer_start(*p_server->p_timer_id, APP_TIMER_MAX_CNT_VAL, p_server);
}
else if (app_timer_ticks >= APP_TIMER_MIN_TIMEOUT_TICKS)
{
status = app_timer_start(*p_server->p_timer_id, APP_TIMER_TICKS(p_server->state.remaining_time_ms), p_server);
}
else
{
status = app_timer_start(*p_server->p_timer_id, APP_TIMER_MIN_TIMEOUT_TICKS, p_server);
}
p_server->last_rtc_counter = app_timer_cnt_get();
}
if (status != NRF_SUCCESS)
{
__LOG(LOG_SRC_APP, LOG_LEVEL_ERROR, "State transition timer error\n");
}
}
static void onoff_state_value_update(app_onoff_server_t * p_server)
{
/* Requirement: If delay and transition time is zero, current state changes to the target state. */
if ((p_server->state.delay_ms == 0 && p_server->state.remaining_time_ms == 0) ||
/* Requirement: If current state is 0 (checked earlier) and target state is 1, current state value changes
* to the target state value immediately after the delay.
*/
(p_server->state.delay_ms == 0 && p_server->state.target_onoff == 1))
{
p_server->state.present_onoff = p_server->state.target_onoff;
simple_on_off_msg_status_t status_params;
status_params.present_on_off = p_server->state.present_onoff;
// status_params.target_on_off = p_server->state.target_onoff;
// status_params.remaining_time_ms = p_server->state.remaining_time_ms;
(void) simple_on_off_server_status_publish(&p_server->server, &status_params);
if (!p_server->value_updated)
{
p_server->onoff_set_cb(p_server, p_server->state.present_onoff);
p_server->value_updated = true;
}
}
__LOG(LOG_SRC_APP, LOG_LEVEL_DBG1, "cur onoff: %d target: %d delay: %d ms remaining time: %d ms\n",
p_server->state.present_onoff, p_server->state.target_onoff, p_server->state.delay_ms, p_server->state.remaining_time_ms);
}
static void onoff_state_timer_cb(void * p_context)
{
app_onoff_server_t * p_server = (app_onoff_server_t *) p_context;
/* Requirement: Process timing. Process the delay first (Non-zero delay will delay the required
* state transition by the specified amount) and then the transition time.
*/
if (p_server->state.delay_ms != 0)
{
p_server->state.delay_ms = 0;
onoff_state_value_update(p_server);
}
else if (p_server->state.remaining_time_ms != 0)
{
if (APP_TIMER_TICKS(p_server->state.remaining_time_ms) > APP_TIMER_MAX_CNT_VAL)
{
p_server->state.remaining_time_ms -= (APP_TIMER_MAX_CNT_VAL/APP_TIMER_CLOCK_FREQ);
}
else
{
p_server->state.remaining_time_ms = 0;
onoff_state_value_update(p_server);
}
}
onoff_state_process_timing(p_server);
}
/***** Generic OnOff model interface callbacks *****/
static void simple_onoff_state_get_cb(const simple_on_off_server_t * p_self)
{
__LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "msg: GET \n");
app_onoff_server_t * p_server = PARENT_BY_FIELD_GET(app_onoff_server_t, server, p_self);
/* Requirement: Provide the current value of the OnOff state */
p_server->onoff_get_cb(p_server, &p_server->state.present_onoff);
// p_out->present_on_off = p_server->state.present_onoff;
// p_out->target_on_off = p_server->state.target_onoff;
/* Requirement: Always report remaining time */
/* if (p_server->state.remaining_time_ms > 0 && p_server->state.delay_ms == 0)
{
uint32_t delta = (1000ul * app_timer_cnt_diff_compute(app_timer_cnt_get(), p_server->last_rtc_counter)) / APP_TIMER_CLOCK_FREQ;
if (p_server->state.remaining_time_ms >= delta && delta > 0)
{
p_out->remaining_time_ms = p_server->state.remaining_time_ms - delta;
}
else
{
p_out->remaining_time_ms = 0;
}
}
else
{
p_out->remaining_time_ms = p_server->state.remaining_time_ms;
}*/
}
static void simple_onoff_state_set_cb(const simple_on_off_server_t * p_self, bool on_off)
{
__LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "msg: SET: %d\n", on_off);
app_onoff_server_t * p_server = PARENT_BY_FIELD_GET(app_onoff_server_t, server, p_self);
/* Update internal representation of OnOff value, process timing */
p_server->value_updated = false;
// p_server->state.target_onoff = p_in->on_off;
onoff_state_value_update(p_server);
onoff_state_process_timing(p_server);
}
/***** Interface functions *****/
void app_onoff_status_publish(app_onoff_server_t * p_server)
{
p_server->onoff_get_cb(p_server, &p_server->state.present_onoff);
p_server->state.target_onoff = p_server->state.present_onoff;
p_server->state.delay_ms = 0;
p_server->state.remaining_time_ms = 0;
(void) app_timer_stop(*p_server->p_timer_id);
simple_on_off_msg_status_t status = {
.present_on_off = p_server->state.present_onoff,
.target_on_off = p_server->state.target_onoff,
.remaining_time_ms = p_server->state.remaining_time_ms
};
(void) simple_on_off_server_status_publish(&p_server->server, &status);
}
uint32_t app_onoff_init(app_onoff_server_t * p_server, uint8_t element_index)
{
uint32_t status = NRF_ERROR_INTERNAL;
if (p_server == NULL)
{
return NRF_ERROR_NULL;
}
p_server->server.p_callbacks = &onoff_srv_cbs;
if (p_server->onoff_set_cb == NULL || p_server->onoff_get_cb == NULL)
{
return NRF_ERROR_NULL;
}
status = simple_on_off_server_init(&p_server->server, element_index);
if (status == NRF_SUCCESS)
{
status = app_timer_create(p_server->p_timer_id, APP_TIMER_MODE_SINGLE_SHOT,
onoff_state_timer_cb);
}
return status;
}
/* Copyright (c) 2010 - 2018, Nordic Semiconductor ASA
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "simple_on_off_server.h"
#include "simple_on_off_common.h"
#include <stdint.h>
#include <stddef.h>
#include "access.h"
#include "nrf_mesh_assert.h"
/*****************************************************************************
* Static functions
*****************************************************************************/
static void reply_status(const simple_on_off_server_t * p_server,
const access_message_rx_t * p_message,
bool present_on_off)
{
simple_on_off_msg_status_t status;
status.present_on_off = present_on_off ? 1 : 0;
access_message_tx_t reply;
reply.opcode.opcode = SIMPLE_ON_OFF_OPCODE_STATUS;
reply.opcode.company_id = SIMPLE_ON_OFF_COMPANY_ID;
reply.p_buffer = (const uint8_t *) &status;
reply.length = sizeof(status);
reply.force_segmented = false;
reply.transmic_size = NRF_MESH_TRANSMIC_SIZE_DEFAULT;
reply.access_token = nrf_mesh_unique_token_get();
(void) access_model_reply(p_server->model_handle, p_message, &reply);
}
/*****************************************************************************
* Opcode handler callbacks
*****************************************************************************/
static void handle_set_cb(access_model_handle_t handle, const access_message_rx_t * p_message, void * p_args)
{
simple_on_off_server_t * p_server = p_args;
NRF_MESH_ASSERT(p_server->set_cb != NULL);
bool value = (((simple_on_off_msg_set_t*) p_message->p_data)->on_off) > 0;
value = p_server->set_cb(p_server, value);
reply_status(p_server, p_message, value);
(void) simple_on_off_server_status_publish(p_server, value); /* We don't care about status */
}
static void handle_get_cb(access_model_handle_t handle, const access_message_rx_t * p_message, void * p_args)
{
simple_on_off_server_t * p_server = p_args;
NRF_MESH_ASSERT(p_server->get_cb != NULL);
reply_status(p_server, p_message, p_server->get_cb(p_server));
}
static void handle_set_unreliable_cb(access_model_handle_t handle, const access_message_rx_t * p_message, void * p_args)
{
simple_on_off_server_t * p_server = p_args;
NRF_MESH_ASSERT(p_server->set_cb != NULL);
bool value = (((simple_on_off_msg_set_unreliable_t*) p_message->p_data)->on_off) > 0;
value = p_server->set_cb(p_server, value);
(void)simple_on_off_server_status_publish(p_server, value);
}
static const access_opcode_handler_t m_opcode_handlers[] =
{
{ACCESS_OPCODE_VENDOR(SIMPLE_ON_OFF_OPCODE_SET, SIMPLE_ON_OFF_COMPANY_ID), handle_set_cb},
{ACCESS_OPCODE_VENDOR(SIMPLE_ON_OFF_OPCODE_GET, SIMPLE_ON_OFF_COMPANY_ID), handle_get_cb},
{ACCESS_OPCODE_VENDOR(SIMPLE_ON_OFF_OPCODE_SET_UNRELIABLE, SIMPLE_ON_OFF_COMPANY_ID), handle_set_unreliable_cb}
};
/*****************************************************************************
* Public API
*****************************************************************************/
uint32_t simple_on_off_server_init(simple_on_off_server_t * p_server, uint16_t element_index)
{
if (p_server == NULL ||
p_server->get_cb == NULL ||
p_server->set_cb == NULL)
{
return NRF_ERROR_NULL;
}
access_model_add_params_t init_params;
init_params.element_index = element_index;
init_params.model_id.model_id = SIMPLE_ON_OFF_SERVER_MODEL_ID;
init_params.model_id.company_id = SIMPLE_ON_OFF_COMPANY_ID;
init_params.p_opcode_handlers = &m_opcode_handlers[0];
init_params.opcode_count = sizeof(m_opcode_handlers) / sizeof(m_opcode_handlers[0]);
init_params.p_args = p_server;
init_params.publish_timeout_cb = NULL;
return access_model_add(&init_params, &p_server->model_handle);
}
uint32_t simple_on_off_server_status_publish(simple_on_off_server_t * p_server, bool value)
{
simple_on_off_msg_status_t status;
status.present_on_off = value ? 1 : 0;
access_message_tx_t msg;
msg.opcode.opcode = SIMPLE_ON_OFF_OPCODE_STATUS;
msg.opcode.company_id = SIMPLE_ON_OFF_COMPANY_ID;
msg.p_buffer = (const uint8_t *) &status;
msg.length = sizeof(status);
msg.force_segmented = false;
msg.transmic_size = NRF_MESH_TRANSMIC_SIZE_DEFAULT;
msg.access_token = nrf_mesh_unique_token_get();
return access_model_publish(p_server->model_handle, &msg);
}
/* Copyright (c) 2010 - 2018, Nordic Semiconductor ASA
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "simple_on_off_client.h"
#include "simple_on_off_common.h"
#include <stdint.h>
#include <stddef.h>
#include "access.h"
#include "access_config.h"
#include "access_reliable.h"
#include "device_state_manager.h"
#include "nrf_mesh.h"
#include "nrf_mesh_assert.h"
#include "log.h"
/*****************************************************************************
* Static variables
*****************************************************************************/
/** Keeps a single global TID for all transfers. */
static uint8_t m_tid;
/*****************************************************************************
* Static functions
*****************************************************************************/
static void reliable_status_cb(access_model_handle_t model_handle,
void * p_args,
access_reliable_status_t status)
{
simple_on_off_client_t * p_client = p_args;
NRF_MESH_ASSERT(p_client->status_cb != NULL);
p_client->state.reliable_transfer_active = false;
switch (status)
{
case ACCESS_RELIABLE_TRANSFER_SUCCESS:
/* Ignore */
break;
case ACCESS_RELIABLE_TRANSFER_TIMEOUT:
p_client->status_cb(p_client, SIMPLE_ON_OFF_STATUS_ERROR_NO_REPLY, NRF_MESH_ADDR_UNASSIGNED);
break;
case ACCESS_RELIABLE_TRANSFER_CANCELLED:
p_client->status_cb(p_client, SIMPLE_ON_OFF_STATUS_CANCELLED, NRF_MESH_ADDR_UNASSIGNED);
break;
default:
/* Should not be possible. */
NRF_MESH_ASSERT(false);
break;
}
}
/** Returns @c true if the message received was from the address corresponding to the clients
* publish address. */
static bool is_valid_source(const simple_on_off_client_t * p_client,
const access_message_rx_t * p_message)
{
/* Check the originator of the status. */
dsm_handle_t publish_handle;
nrf_mesh_address_t publish_address;
if (access_model_publish_address_get(p_client->model_handle, &publish_handle) != NRF_SUCCESS ||
publish_handle == DSM_HANDLE_INVALID ||
dsm_address_get(publish_handle, &publish_address) != NRF_SUCCESS ||
publish_address.value != p_message->meta_data.src.value)
{
return false;
}
else
{
return true;
}
}
static uint32_t send_reliable_message(const simple_on_off_client_t * p_client,
simple_on_off_opcode_t opcode,
const uint8_t * p_data,
uint16_t length)
{
access_reliable_t reliable;
reliable.model_handle = p_client->model_handle;
reliable.message.p_buffer = p_data;
reliable.message.length = length;
reliable.message.opcode.opcode = opcode;
reliable.message.opcode.company_id = SIMPLE_ON_OFF_COMPANY_ID;
reliable.message.force_segmented = false;
reliable.message.transmic_size = NRF_MESH_TRANSMIC_SIZE_DEFAULT;
reliable.message.access_token = nrf_mesh_unique_token_get();
reliable.reply_opcode.opcode = SIMPLE_ON_OFF_OPCODE_STATUS;
reliable.reply_opcode.company_id = SIMPLE_ON_OFF_COMPANY_ID;
reliable.timeout = ACCESS_RELIABLE_TIMEOUT_MIN;
reliable.status_cb = reliable_status_cb;
return access_model_reliable_publish(&reliable);
}
/*****************************************************************************
* Opcode handler callback(s)
*****************************************************************************/
static void handle_status_cb(access_model_handle_t handle, const access_message_rx_t * p_message, void * p_args)
{
simple_on_off_client_t * p_client = p_args;
NRF_MESH_ASSERT(p_client->status_cb != NULL);
if (!is_valid_source(p_client, p_message))
{
return;
}
simple_on_off_msg_status_t * p_status =
(simple_on_off_msg_status_t *) p_message->p_data;
simple_on_off_status_t on_off_status = (p_status->present_on_off ?
SIMPLE_ON_OFF_STATUS_ON : SIMPLE_ON_OFF_STATUS_OFF);
p_client->status_cb(p_client, on_off_status, p_message->meta_data.src.value);
}
static const access_opcode_handler_t m_opcode_handlers[] =
{
{{SIMPLE_ON_OFF_OPCODE_STATUS, SIMPLE_ON_OFF_COMPANY_ID}, handle_status_cb}
};
static void handle_publish_timeout(access_model_handle_t handle, void * p_args)
{
simple_on_off_client_t * p_client = p_args;
if (p_client->timeout_cb != NULL)
{
p_client->timeout_cb(handle, p_args);
}
}
/*****************************************************************************
* Public API
*****************************************************************************/
uint32_t simple_on_off_client_init(simple_on_off_client_t * p_client, uint16_t element_index)
{
if (p_client == NULL ||
p_client->status_cb == NULL)
{
return NRF_ERROR_NULL;
}
access_model_add_params_t init_params;
init_params.model_id.model_id = SIMPLE_ON_OFF_CLIENT_MODEL_ID;
init_params.model_id.company_id = SIMPLE_ON_OFF_COMPANY_ID;
init_params.element_index = element_index;
init_params.p_opcode_handlers = &m_opcode_handlers[0];
init_params.opcode_count = sizeof(m_opcode_handlers) / sizeof(m_opcode_handlers[0]);
init_params.p_args = p_client;
init_params.publish_timeout_cb = handle_publish_timeout;
return access_model_add(&init_params, &p_client->model_handle);
}
uint32_t simple_on_off_client_set(simple_on_off_client_t * p_client, bool on_off)
{
if (p_client == NULL || p_client->status_cb == NULL)
{
return NRF_ERROR_NULL;
}
else if (p_client->state.reliable_transfer_active)
{
return NRF_ERROR_INVALID_STATE;
}
p_client->state.data.on_off = on_off ? 1 : 0;
p_client->state.data.tid = m_tid++;
uint32_t status = send_reliable_message(p_client,
SIMPLE_ON_OFF_OPCODE_SET,
(const uint8_t *)&p_client->state.data,
sizeof(simple_on_off_msg_set_t));
if (status == NRF_SUCCESS)
{
p_client->state.reliable_transfer_active = true;
}
return status;
}
uint32_t simple_on_off_client_set_unreliable(simple_on_off_client_t * p_client, bool on_off, uint8_t repeats)
{
simple_on_off_msg_set_unreliable_t set_unreliable;
set_unreliable.on_off = on_off ? 1 : 0;
set_unreliable.tid = m_tid++;
access_message_tx_t message;
message.opcode.opcode = SIMPLE_ON_OFF_OPCODE_SET_UNRELIABLE;
message.opcode.company_id = SIMPLE_ON_OFF_COMPANY_ID;
message.p_buffer = (const uint8_t*) &set_unreliable;
message.length = sizeof(set_unreliable);
message.force_segmented = false;
message.transmic_size = NRF_MESH_TRANSMIC_SIZE_DEFAULT;
uint32_t status = NRF_SUCCESS;
for (uint8_t i = 0; i < repeats; ++i)
{
message.access_token = nrf_mesh_unique_token_get();
status = access_model_publish(p_client->model_handle, &message);
if (status != NRF_SUCCESS)
{
break;
}
}
return status;
}
uint32_t simple_on_off_client_get(simple_on_off_client_t * p_client)
{
if (p_client == NULL || p_client->status_cb == NULL)
{
return NRF_ERROR_NULL;
}
else if (p_client->state.reliable_transfer_active)
{
return NRF_ERROR_INVALID_STATE;
}
uint32_t status = send_reliable_message(p_client,
SIMPLE_ON_OFF_OPCODE_GET,
NULL,
0);
if (status == NRF_SUCCESS)
{
p_client->state.reliable_transfer_active = true;
}
return status;
}
/**
* Cancel any ongoing reliable message transfer.
*
* @param[in] p_client Pointer to the client instance structure.
*/
void simple_on_off_client_pending_msg_cancel(simple_on_off_client_t * p_client)
{
(void)access_model_reliable_cancel(p_client->model_handle);
}
