simple_on_off vendor model on Mesh 3.1

RE: simple_on_off vendor model on Mesh 3.1

AndreasF — Thu, 14 Feb 2019 09:12:33 GMT

Hi.

Great to see that you solved the problem! I would like to wish you good luck with further work!

Best regards,

Andreas

RE: simple_on_off vendor model on Mesh 3.1

melt — Wed, 13 Feb 2019 15:57:41 GMT

Hi Andreas I have managed to compile and run the Vendor_client model

problem was as per below p.uuid=NULL,

 mesh_stack_init_params_t init_params =
    {
        .core.irq_priority       = NRF_MESH_IRQ_PRIORITY_LOWEST,
        .core.lfclksrc           = DEV_BOARD_LF_CLK_CFG,
        .core.p_uuid             = NULL,//dev_uuid,
        .models.models_init_cb   = models_init_cb,
        .models.config_server_cb = config_server_evt_cb
    };
    ERROR_CHECK(mesh_stack_init(&init_params, &m_device_provisioned));
}

Complete main.c for vendor client on off model below

/* 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 <stdint.h>
#include <string.h>

/* HAL */
#include "boards.h"
#include "simple_hal.h"
#include "app_timer.h"

/* Core */
#include "nrf_mesh_config_core.h"
#include "nrf_mesh_gatt.h"
#include "nrf_mesh_configure.h"
#include "nrf_mesh.h"
#include "mesh_stack.h"
#include "device_state_manager.h"
#include "access_config.h"

/* Provisioning and configuration */
#include "mesh_provisionee.h"
#include "mesh_app_utils.h"

/* Models */

#include "simple_on_off_client.h"
#include "simple_on_off_common.h"

/* Logging and RTT */
#include "log.h"
#include "rtt_input.h"

/* Example specific includes */
#include "app_config.h"
#include "nrf_mesh_config_examples.h"
#include "light_switch_example_common.h"
#include "example_common.h"
#include "ble_softdevice_support.h"

#define APP_STATE_OFF                (0)
#define APP_STATE_ON                 (1)

#define APP_UNACK_MSG_REPEAT_COUNT   (2)

 #define DEV_BOARD_LF_CLK_CFG  { \
        .source = NRF_SDH_CLOCK_LF_SRC, \
        .rc_ctiv = NRF_SDH_CLOCK_LF_RC_CTIV, \
        .rc_temp_ctiv = NRF_SDH_CLOCK_LF_RC_TEMP_CTIV, \
        .accuracy = NRF_SDH_CLOCK_LF_ACCURACY \
    }
#define RTT_INPUT_POLL_PERIOD_MS (100)
#define GROUP_MSG_REPEAT_COUNT (2)

#define LED_BLINK_INTERVAL_MS (200)
#define LED_BLINK_SHORT_INTERVAL_MS (50)
#define LED_BLINK_CNT_START (2)
#define LED_BLINK_CNT_RESET (3)
#define LED_BLINK_CNT_PROV (4)
#define LED_BLINK_CNT_NO_REPLY (6)

static simple_on_off_client_t m_clients[CLIENT_MODEL_INSTANCE_COUNT];
//static const uint8_t m_client_node_uuid[NRF_MESH_UUID_SIZE] = CLIENT_NODE_UUID;
static bool m_device_provisioned;

//static void client_status_cb(const simple_on_off_client_t *p_self, simple_on_off_status_t status, uint16_t src);
static bool client_publication_configured(void) {
  dsm_handle_t pub_addr_handle;
  for (uint8_t i = 0; i < CLIENT_MODEL_INSTANCE_COUNT; i++) {
    if (access_model_publish_address_get(m_clients[i].model_handle, &pub_addr_handle) == NRF_SUCCESS) {
      if (pub_addr_handle == DSM_HANDLE_INVALID) {
        return false;
      }
    } else {
      return false;
    }
  }

  return true;
}


static void device_identification_start_cb(uint8_t attention_duration_s)
{
    hal_led_mask_set(LEDS_MASK, false);
    hal_led_blink_ms(BSP_LED_2_MASK  | BSP_LED_3_MASK,
                     LED_BLINK_ATTENTION_INTERVAL_MS,
                     LED_BLINK_ATTENTION_COUNT(attention_duration_s));
}

static void provisioning_aborted_cb(void)
{
    hal_led_blink_stop();
}


static void provisioning_complete_cb(void) {
  __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Successfully provisioned\n");

  dsm_local_unicast_address_t node_address;
  dsm_local_unicast_addresses_get(&node_address);
  __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Node Address: 0x%04x \n", node_address.address_start);

  hal_led_mask_set(LEDS_MASK, LED_MASK_STATE_OFF);
  hal_led_blink_ms(LEDS_MASK, LED_BLINK_INTERVAL_MS, LED_BLINK_CNT_PROV);
}

static uint32_t server_index_get(const simple_on_off_client_t *p_client) {
  uint32_t index = p_client - &m_clients[0];
  NRF_MESH_ASSERT(index < SERVER_NODE_COUNT);
  return index;
}

static void client_publish_timeout_cb(access_model_handle_t handle, void *p_self) {
  __LOG(LOG_SRC_APP, LOG_LEVEL_ERROR, "Acknowledged send timedout\n");
}

static void client_status_cb(const simple_on_off_client_t *p_self, simple_on_off_status_t status, uint16_t src) {
  uint32_t server_index = server_index_get(p_self);

  //__LOG(LOG_SRC_APP, LOG_LEVEL_ERROR, "server status received \n",p_self);
  switch (status) {
  case SIMPLE_ON_OFF_STATUS_ON:
    hal_led_pin_set(BSP_LED_0 + server_index, true);
    break;

  case SIMPLE_ON_OFF_STATUS_OFF:
    hal_led_pin_set(BSP_LED_0 + server_index, false);
    break;

  case SIMPLE_ON_OFF_STATUS_ERROR_NO_REPLY:
    hal_led_blink_ms(LEDS_MASK, LED_BLINK_SHORT_INTERVAL_MS, LED_BLINK_CNT_NO_REPLY);
    break;

  case SIMPLE_ON_OFF_STATUS_CANCELLED:
  default:
    __LOG(LOG_SRC_APP, LOG_LEVEL_ERROR, "Unknown status \n");
    break;
  }
}

static void node_reset(void) {
  __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- Node reset  -----\n");
  hal_led_blink_ms(LEDS_MASK, LED_BLINK_INTERVAL_MS, LED_BLINK_CNT_RESET);
  //uint32_t status = config_client_node_reset();
  //__LOG(LOG_SRC_APP, LOG_LEVEL_ERROR,"Node Reset Status:0x%08lX\n",status); 
  /* This function may return if there are ongoing flash operations. */
  mesh_stack_device_reset();

}

static void config_server_evt_cb(const config_server_evt_t *p_evt) {
  if (p_evt->type == CONFIG_SERVER_EVT_NODE_RESET) {
    node_reset();
  }
}

static void button_event_handler(uint32_t button_number) {
  //__LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Button %u pressed\n", button_number);

  if (client_publication_configured()) {
    uint32_t status = NRF_SUCCESS;
    switch (button_number) {
    case 0:
    case 1:
      /* send unicast message, with inverted GPIO pin value */
     
      status = simple_on_off_client_set(&m_clients[button_number],
          !hal_led_pin_get(BSP_LED_0 + button_number));

      break;

    case 2:
    case 3:
      
      /* send a group message to the ODD group, with inverted GPIO pin value */
      status = simple_on_off_client_set_unreliable(&m_clients[button_number],
          !hal_led_pin_get(BSP_LED_0 + button_number),
          GROUP_MSG_REPEAT_COUNT);
      hal_led_pin_set(BSP_LED_0 + button_number, !hal_led_pin_get(BSP_LED_0 + button_number));
      break;
    default:
      break;
    }

    if (status == NRF_ERROR_INVALID_STATE ||
        status == NRF_ERROR_NO_MEM ||
        status == NRF_ERROR_BUSY) {
      __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Cannot send. Device is busy.\n");
      hal_led_blink_ms(LEDS_MASK, LED_BLINK_SHORT_INTERVAL_MS, LED_BLINK_CNT_NO_REPLY);
    } else {
      ERROR_CHECK(status);
    }
  } else {
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Ignored. Node is not configured.\n");
  }
}
/*uint32_t send_command_client(simple_on_off_client_t *p_client, uint8_t *msg, uint16_t length) {
  //int i;
  send_command_msg_t command_msg;

  command_msg.length = length;
  strncpy(command_msg.command, msg, length);

  access_message_tx_t message;
  message.opcode.opcode = SEND_COMMAND;
  message.opcode.company_id = ACCESS_COMPANY_ID_NORDIC;
  message.p_buffer = (const uint8_t *)&command_msg;
  message.length = command_msg.length + 2;

  uint32_t status = NRF_SUCCESS;

  status = access_model_publish(p_client->model_handle, &message);

  Method for sending to all nodes!
  for (uint8_t i = 0; i < 3; ++i)
    {
        status = access_model_publish(p_client->model_handle, &message);
        if (status == NRF_SUCCESS) {
            break;
        }
    }
  return status;
}*/

static void rtt_input_handler(int key)
{
    if (key >= '0' && key <= '3')
    {
        uint32_t button_number = key - '0';
        button_event_handler(button_number);
    }

}

static void models_init_cb(void) {
  __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Initializing and adding models\n");

  for (uint32_t i = 0; i < CLIENT_MODEL_INSTANCE_COUNT; ++i) {
    m_clients[i].status_cb = client_status_cb;
    m_clients[i].timeout_cb = client_publish_timeout_cb;
    ERROR_CHECK(simple_on_off_client_init(&m_clients[i], i + 1));
    ERROR_CHECK(access_model_subscription_list_alloc(m_clients[i].model_handle));
  }
}

static void mesh_init(void)
{
    uint8_t dev_uuid[NRF_MESH_UUID_SIZE];
    uint8_t node_uuid_prefix[NODE_UUID_PREFIX_LEN] = CLIENT_NODE_UUID_PREFIX;

  
    mesh_stack_init_params_t init_params =
    {
        .core.irq_priority       = NRF_MESH_IRQ_PRIORITY_LOWEST,
        .core.lfclksrc           = DEV_BOARD_LF_CLK_CFG,
        .core.p_uuid             = NULL,//dev_uuid,
        .models.models_init_cb   = models_init_cb,
        .models.config_server_cb = config_server_evt_cb
    };
    ERROR_CHECK(mesh_stack_init(&init_params, &m_device_provisioned));
}
static void initialize(void)
{
    __LOG_INIT(LOG_SRC_APP | LOG_SRC_ACCESS | LOG_SRC_BEARER, LOG_LEVEL_INFO, LOG_CALLBACK_DEFAULT);
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- PCA10059 client -----\n");

    ERROR_CHECK(app_timer_init());
    hal_leds_init();

#if BUTTON_BOARD
    ERROR_CHECK(hal_buttons_init(button_event_handler));
#endif

    ble_stack_init();

#if MESH_FEATURE_GATT_ENABLED
    gap_params_init();
    conn_params_init();
#endif

    mesh_init();
}

static void start(void) 
{
  rtt_input_enable(rtt_input_handler, RTT_INPUT_POLL_PERIOD_MS);
  //ERROR_CHECK(mesh_stack_start());

  if (!m_device_provisioned) {
    static const uint8_t static_auth_data[NRF_MESH_KEY_SIZE] = STATIC_AUTH_DATA;
    mesh_provisionee_start_params_t prov_start_params =
        {
            .p_static_data    = static_auth_data,
            .prov_complete_cb = provisioning_complete_cb,
            .prov_device_identification_start_cb = device_identification_start_cb,
            .prov_device_identification_stop_cb = NULL,
            .prov_abort_cb = provisioning_aborted_cb,
            .p_device_uri = EX_URI_LS_CLIENT
};
    ERROR_CHECK(mesh_provisionee_prov_start(&prov_start_params));
  }

    mesh_app_uuid_print(nrf_mesh_configure_device_uuid_get());

    ERROR_CHECK(mesh_stack_start());

//  const uint8_t *p_uuid = nrf_mesh_configure_device_uuid_get();
//  __LOG_XB(LOG_SRC_APP, LOG_LEVEL_INFO, "Device UUID ", p_uuid, NRF_MESH_UUID_SIZE);

  hal_led_mask_set(LEDS_MASK, LED_MASK_STATE_OFF);
  hal_led_blink_ms(LEDS_MASK, LED_BLINK_INTERVAL_MS, LED_BLINK_CNT_START);
}


int main(void) 
{
  initialize();
  start();

  for (;;) {
    (void)sd_app_evt_wait();
  }
}

RE: simple_on_off vendor model on Mesh 3.1

melt — Wed, 13 Feb 2019 13:50:45 GMT

I do have the source file thanks , my problem is Im not sure how to add it to static void mesh_init(void)

and static void models_init_cb(void) for MESH 3.1. Im either getting compile errors and when it does compile im sitting with mesh error 8.

the server side is working but the client side is not. When I provision the server the elements come us as vendor model which is correct.

must I remove the generic_on_off .c and .h files from the solution or keep them there ?

my latest main.c for client below . Im not getting the uuid in RTT viewer just the following

<t: 0>, main.c, 300, ----- BLE Mesh Light Switch Client Demo -----
<t: 13072>, main.c, 271, Initializing and adding models
<t: 17971>, app_error_weak.c, 108, Mesh assert at 0x0002ACB2 (:0)

thanks for the help.

/* 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 <stdint.h>
#include <string.h>

/* HAL */
#include "boards.h"
#include "simple_hal.h"
#include "app_timer.h"

/* Core */
#include "nrf_mesh_config_core.h"
#include "nrf_mesh_gatt.h"
#include "nrf_mesh_configure.h"
#include "nrf_mesh.h"
#include "mesh_stack.h"
#include "device_state_manager.h"
#include "access_config.h"

/* Provisioning and configuration */
#include "mesh_provisionee.h"
#include "mesh_app_utils.h"

/* Models */

#include "simple_on_off_client.h"
#include "simple_on_off_common.h"

/* Logging and RTT */
#include "log.h"
#include "rtt_input.h"

/* Example specific includes */
#include "app_config.h"
#include "nrf_mesh_config_examples.h"
#include "light_switch_example_common.h"
#include "example_common.h"
#include "ble_softdevice_support.h"

#define APP_STATE_OFF                (0)
#define APP_STATE_ON                 (1)

#define APP_UNACK_MSG_REPEAT_COUNT   (2)

 #define DEV_BOARD_LF_CLK_CFG  { \
        .source = NRF_SDH_CLOCK_LF_SRC, \
        .rc_ctiv = NRF_SDH_CLOCK_LF_RC_CTIV, \
        .rc_temp_ctiv = NRF_SDH_CLOCK_LF_RC_TEMP_CTIV, \
        .accuracy = NRF_SDH_CLOCK_LF_ACCURACY \
    }
#define RTT_INPUT_POLL_PERIOD_MS (100)
#define GROUP_MSG_REPEAT_COUNT (2)

#define LED_BLINK_INTERVAL_MS (200)
#define LED_BLINK_SHORT_INTERVAL_MS (50)
#define LED_BLINK_CNT_START (2)
#define LED_BLINK_CNT_RESET (3)
#define LED_BLINK_CNT_PROV (4)
#define LED_BLINK_CNT_NO_REPLY (6)

static simple_on_off_client_t m_clients[CLIENT_MODEL_INSTANCE_COUNT];
//static const uint8_t m_client_node_uuid[NRF_MESH_UUID_SIZE] = CLIENT_NODE_UUID;
static bool m_device_provisioned;

//static void client_status_cb(const simple_on_off_client_t *p_self, simple_on_off_status_t status, uint16_t src);
static bool client_publication_configured(void) {
  dsm_handle_t pub_addr_handle;
  for (uint8_t i = 0; i < CLIENT_MODEL_INSTANCE_COUNT; i++) {
    if (access_model_publish_address_get(m_clients[i].model_handle, &pub_addr_handle) == NRF_SUCCESS) {
      if (pub_addr_handle == DSM_HANDLE_INVALID) {
        return false;
      }
    } else {
      return false;
    }
  }

  return true;
}


static void device_identification_start_cb(uint8_t attention_duration_s)
{
    hal_led_mask_set(LEDS_MASK, false);
    hal_led_blink_ms(BSP_LED_2_MASK  | BSP_LED_3_MASK,
                     LED_BLINK_ATTENTION_INTERVAL_MS,
                     LED_BLINK_ATTENTION_COUNT(attention_duration_s));
}

static void provisioning_aborted_cb(void)
{
    hal_led_blink_stop();
}


static void provisioning_complete_cb(void) {
  __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Successfully provisioned\n");

  dsm_local_unicast_address_t node_address;
  dsm_local_unicast_addresses_get(&node_address);
  __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Node Address: 0x%04x \n", node_address.address_start);

  hal_led_mask_set(LEDS_MASK, LED_MASK_STATE_OFF);
  hal_led_blink_ms(LEDS_MASK, LED_BLINK_INTERVAL_MS, LED_BLINK_CNT_PROV);
}

static uint32_t server_index_get(const simple_on_off_client_t *p_client) {
  uint32_t index = p_client - &m_clients[0];
  NRF_MESH_ASSERT(index < SERVER_NODE_COUNT);
  return index;
}

static void client_publish_timeout_cb(access_model_handle_t handle, void *p_self) {
  __LOG(LOG_SRC_APP, LOG_LEVEL_ERROR, "Acknowledged send timedout\n");
}

static void client_status_cb(const simple_on_off_client_t *p_self, simple_on_off_status_t status, uint16_t src) {
  uint32_t server_index = server_index_get(p_self);

  //__LOG(LOG_SRC_APP, LOG_LEVEL_ERROR, "server status received \n",p_self);
  switch (status) {
  case SIMPLE_ON_OFF_STATUS_ON:
    hal_led_pin_set(BSP_LED_0 + server_index, true);
    break;

  case SIMPLE_ON_OFF_STATUS_OFF:
    hal_led_pin_set(BSP_LED_0 + server_index, false);
    break;

  case SIMPLE_ON_OFF_STATUS_ERROR_NO_REPLY:
    hal_led_blink_ms(LEDS_MASK, LED_BLINK_SHORT_INTERVAL_MS, LED_BLINK_CNT_NO_REPLY);
    break;

  case SIMPLE_ON_OFF_STATUS_CANCELLED:
  default:
    __LOG(LOG_SRC_APP, LOG_LEVEL_ERROR, "Unknown status \n");
    break;
  }
}

static void node_reset(void) {
  __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- Node reset  -----\n");
  hal_led_blink_ms(LEDS_MASK, LED_BLINK_INTERVAL_MS, LED_BLINK_CNT_RESET);
  //uint32_t status = config_client_node_reset();
  //__LOG(LOG_SRC_APP, LOG_LEVEL_ERROR,"Node Reset Status:0x%08lX\n",status); 
  /* This function may return if there are ongoing flash operations. */
  mesh_stack_device_reset();

}

static void config_server_evt_cb(const config_server_evt_t *p_evt) {
  if (p_evt->type == CONFIG_SERVER_EVT_NODE_RESET) {
    node_reset();
  }
}

static void button_event_handler(uint32_t button_number) {
  //__LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Button %u pressed\n", button_number);

  if (client_publication_configured()) {
    uint32_t status = NRF_SUCCESS;
    switch (button_number) {
    case 0:
    case 1:
      /* send unicast message, with inverted GPIO pin value */
     
      status = simple_on_off_client_set(&m_clients[button_number],
          !hal_led_pin_get(BSP_LED_0 + button_number));

      break;

    case 2:
    case 3:
      
      /* send a group message to the ODD group, with inverted GPIO pin value */
      status = simple_on_off_client_set_unreliable(&m_clients[button_number],
          !hal_led_pin_get(BSP_LED_0 + button_number),
          GROUP_MSG_REPEAT_COUNT);
      hal_led_pin_set(BSP_LED_0 + button_number, !hal_led_pin_get(BSP_LED_0 + button_number));
      break;
    default:
      break;
    }

    if (status == NRF_ERROR_INVALID_STATE ||
        status == NRF_ERROR_NO_MEM ||
        status == NRF_ERROR_BUSY) {
      __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Cannot send. Device is busy.\n");
      hal_led_blink_ms(LEDS_MASK, LED_BLINK_SHORT_INTERVAL_MS, LED_BLINK_CNT_NO_REPLY);
    } else {
      ERROR_CHECK(status);
    }
  } else {
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Ignored. Node is not configured.\n");
  }
}
/*uint32_t send_command_client(simple_on_off_client_t *p_client, uint8_t *msg, uint16_t length) {
  //int i;
  send_command_msg_t command_msg;

  command_msg.length = length;
  strncpy(command_msg.command, msg, length);

  access_message_tx_t message;
  message.opcode.opcode = SEND_COMMAND;
  message.opcode.company_id = ACCESS_COMPANY_ID_NORDIC;
  message.p_buffer = (const uint8_t *)&command_msg;
  message.length = command_msg.length + 2;

  uint32_t status = NRF_SUCCESS;

  status = access_model_publish(p_client->model_handle, &message);

  Method for sending to all nodes!
  for (uint8_t i = 0; i < 3; ++i)
    {
        status = access_model_publish(p_client->model_handle, &message);
        if (status == NRF_SUCCESS) {
            break;
        }
    }
  return status;
}*/

static void rtt_input_handler(int key)
{
    if (key >= '0' && key <= '3')
    {
        uint32_t button_number = key - '0';
        button_event_handler(button_number);
    }

}

static void models_init_cb(void) {
  __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Initializing and adding models\n");

  for (uint32_t i = 0; i < CLIENT_MODEL_INSTANCE_COUNT; ++i) {
    m_clients[i].status_cb = client_status_cb;
    m_clients[i].timeout_cb = client_publish_timeout_cb;
    ERROR_CHECK(simple_on_off_client_init(&m_clients[i], i + 1));
    ERROR_CHECK(access_model_subscription_list_alloc(m_clients[i].model_handle));
  }
}

static void mesh_init(void)
{
    uint8_t dev_uuid[NRF_MESH_UUID_SIZE];
    uint8_t node_uuid_prefix[NODE_UUID_PREFIX_LEN] = CLIENT_NODE_UUID_PREFIX;

  
    mesh_stack_init_params_t init_params =
    {
        .core.irq_priority       = NRF_MESH_IRQ_PRIORITY_LOWEST,
        .core.lfclksrc           = DEV_BOARD_LF_CLK_CFG,
        .core.p_uuid             = dev_uuid,
        .models.models_init_cb   = models_init_cb,
        .models.config_server_cb = config_server_evt_cb
    };
    ERROR_CHECK(mesh_stack_init(&init_params, &m_device_provisioned));
}
static void initialize(void)
{
    __LOG_INIT(LOG_SRC_APP | LOG_SRC_ACCESS | LOG_SRC_BEARER, LOG_LEVEL_INFO, LOG_CALLBACK_DEFAULT);
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- BLE Mesh Light Switch Client Demo -----\n");

    ERROR_CHECK(app_timer_init());
    hal_leds_init();

#if BUTTON_BOARD
    ERROR_CHECK(hal_buttons_init(button_event_handler));
#endif

    ble_stack_init();

#if MESH_FEATURE_GATT_ENABLED
    gap_params_init();
    conn_params_init();
#endif

    mesh_init();
}

static void start(void) 
{
  rtt_input_enable(rtt_input_handler, RTT_INPUT_POLL_PERIOD_MS);
  ERROR_CHECK(mesh_stack_start());

  if (!m_device_provisioned) {
    static const uint8_t static_auth_data[NRF_MESH_KEY_SIZE] = STATIC_AUTH_DATA;
    mesh_provisionee_start_params_t prov_start_params =
        {
            .p_static_data    = static_auth_data,
            .prov_complete_cb = provisioning_complete_cb,
            .prov_device_identification_start_cb = device_identification_start_cb,
            .prov_device_identification_stop_cb = NULL,
            .prov_abort_cb = provisioning_aborted_cb,
            .p_device_uri = EX_URI_LS_CLIENT
};
    ERROR_CHECK(mesh_provisionee_prov_start(&prov_start_params));
  }

    mesh_app_uuid_print(nrf_mesh_configure_device_uuid_get());

    ERROR_CHECK(mesh_stack_start());

//  const uint8_t *p_uuid = nrf_mesh_configure_device_uuid_get();
//  __LOG_XB(LOG_SRC_APP, LOG_LEVEL_INFO, "Device UUID ", p_uuid, NRF_MESH_UUID_SIZE);

  hal_led_mask_set(LEDS_MASK, LED_MASK_STATE_OFF);
  hal_led_blink_ms(LEDS_MASK, LED_BLINK_INTERVAL_MS, LED_BLINK_CNT_START);
}


int main(void) 
{
  initialize();
  start();

  for (;;) {
    (void)sd_app_evt_wait();
  }
}

RE: simple_on_off vendor model on Mesh 3.1

AndreasF — Wed, 13 Feb 2019 12:53:10 GMT

Hi.

The first models_init_cb() has an initialization call inside it for the simple_on_off model, if you look closly.

Are you looking for the source file for this implementation? You can find it in Mesh SDK 2.0.0 under models\simple_on_off\src\simple_on_off_client.c

Here it is:

/* 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.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)
    {
        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);
}

Best regards,

Andreas

RE: simple_on_off vendor model on Mesh 3.1

melt — Wed, 13 Feb 2019 11:23:28 GMT

Thanks Andreas, these are for the Generic model. Im looking for a sample of the functions or sample main.c for simple_on_off model in the vendor directory

They don't work together

RE: simple_on_off vendor model on Mesh 3.1

AndreasF — Wed, 13 Feb 2019 11:20:39 GMT

Hi.

I'm a bit unsure what your question is, are you looking for the implementation of mesh_init() and models_init_cb() where the simple_on_off model were used?

The simple_on_off model was used up to Mesh SDK 2.0.0, after this the generic_on_off model is used, which should be used in real applications using the mesh.

The implementation of mesh_init() and models_init_cb() in Mesh SDK 2.0.0 are for example:

(examples\enocean_switch example)

mesh_init() :

static void mesh_init(void)
{
    uint8_t dev_uuid[NRF_MESH_UUID_SIZE] = CLIENT_NODE_UUID;

    mesh_stack_init_params_t init_params =
    {
        .core.irq_priority       = NRF_MESH_IRQ_PRIORITY_LOWEST,
        .core.lfclksrc           = DEV_BOARD_LF_CLK_CFG,
        .core.p_uuid             = dev_uuid,
        .models.models_init_cb   = models_init_cb,
        .models.config_server_cb = config_server_evt_cb
    };
    ERROR_CHECK(mesh_stack_init(&init_params, &m_device_provisioned));

    /* Register event handler to receive NRF_MESH_EVT_FLASH_STABLE. Application functionality will
    be started after this event */
    nrf_mesh_evt_handler_add(&m_mesh_core_event_handler);
}

models_init_cb() :

static void models_init_cb(void)
{
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Initializing and adding models\n");

    /* Model initialization */
    for (uint32_t i = 0; i < LIGHT_SWITCH_CLIENTS; ++i)
    {
        m_clients[i].status_cb = client_status_cb;
        ERROR_CHECK(simple_on_off_client_init(&m_clients[i], i + 1));
        ERROR_CHECK(access_model_subscription_list_alloc(m_clients[i].model_handle));
    }
}

The implementation of mesh_init() and models_init_cb() in Mesh SDK 3.1.0 are for example:

(examples\enocean_switch example)

mesh_init() :

static void mesh_init(void)
{
    mesh_stack_init_params_t init_params =
    {
        .core.irq_priority       = NRF_MESH_IRQ_PRIORITY_LOWEST,
        .core.lfclksrc           = DEV_BOARD_LF_CLK_CFG,
        .core.p_uuid             = NULL,
        .models.models_init_cb   = models_init_cb,
        .models.config_server_cb = config_server_evt_cb
    };
    ERROR_CHECK(mesh_stack_init(&init_params, &m_device_provisioned));

    /* Register event handler to receive NRF_MESH_EVT_FLASH_STABLE. Application functionality will
    be started after this event */
    nrf_mesh_evt_handler_add(&m_mesh_core_event_handler);
}

models_init_cb() :

static void models_init_cb(void)
{
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Initializing and adding models\n");

    /* Model initialization */
    for (uint32_t i = 0; i < LIGHT_SWITCH_CLIENTS; ++i)
    {
        m_clients[i].settings.p_callbacks = &client_cbs;
        m_clients[i].settings.timeout = 0;
        m_clients[i].settings.force_segmented = APP_CONFIG_FORCE_SEGMENTATION;
        m_clients[i].settings.transmic_size = APP_CONFIG_MIC_SIZE;

        ERROR_CHECK(generic_onoff_client_init(&m_clients[i], i + 1));
    }
}

Is this what you are looking for?

Best regards,

Andreas

RE: simple_on_off vendor model on Mesh 3.1

melt — Tue, 12 Feb 2019 14:05:45 GMT

Yip strings. I have read how to create models and go over it almost every day. Can you please share how these functions are structured for the vendor simple_on_off model.

static void mesh_init(void)

and

static void models_init_cb(void)

thank you.

RE: simple_on_off vendor model on Mesh 3.1

AndreasF — Tue, 12 Feb 2019 13:53:08 GMT

Hi.

Have you read about creating new models for your mesh network?

[quote user="melt777"]Can this model now send messages?[/quote]

Do you mean packages or string messages?

Best regards,

Andreas

RE: simple_on_off vendor model on Mesh 3.1

melt — Tue, 12 Feb 2019 11:25:48 GMT

What I am actually trying to do is send a small string on a mesh. the latest example I found is here

I want to use mesh 3.1. Also looking at the on_off_example I see there is now an included generic_on_off_messages.h file. Can this model now send messages?

RE: simple_on_off vendor model on Mesh 3.1

AndreasF — Tue, 12 Feb 2019 10:21:21 GMT

Hi.

Which Mesh SDK is the code you are trying to integrate from?

Best regards,

Andreas

RE: simple_on_off vendor model on Mesh 3.1

melt — Tue, 12 Feb 2019 06:27:03 GMT

Hi Andreas

Did what you suggested and still have error 8. Do you perhaps have an example of on_off vendor model on mesh 3.1?

Then I can compare.

I know it has something to do with mesh_init and models_init. If I use the default generic_on_off functions of mesh_init and models_init (tegether with generic_onn_off.c and .h files it seems to work.

RE: simple_on_off vendor model on Mesh 3.1

AndreasF — Mon, 11 Feb 2019 12:45:58 GMT

Hi.

I think that your order of calling might be wrong. Looking at your code, it seems that you call mesh_stack_init() without having initialized the Mesh state, which throws an error in nrf_mesh.c, line 284.

Can you call nrf_mesh_enable() before you call mesh_stack_init() and see if this works?

Best regards,

Andreas