examples of simple peripheral/central ble transmission nrf52 series

RE: examples of simple peripheral/central ble transmission nrf52 series

Dev_Guy — Wed, 21 Feb 2024 13:32:02 GMT

Hi, I am having the exact same issue now. Do you remember what the hard fault was caused by?

RE: examples of simple peripheral/central ble transmission nrf52 series

loganmeyer3 — Thu, 14 Jul 2022 14:15:51 GMT

yes it can be closed

RE: examples of simple peripheral/central ble transmission nrf52 series

AHaug — Thu, 14 Jul 2022 09:29:26 GMT

Hi,

I am glad to hear that you figured out the issue!

If you found any information that might help other developers with the same issue, please feel free to share the answer in this case. Else I would like to know if I can close this ticket? You may always open a new one in case you need an answer to a new question

Kind regards,
Andreas

RE: examples of simple peripheral/central ble transmission nrf52 series

loganmeyer3 — Wed, 13 Jul 2022 21:14:01 GMT

thanks for the help i seem to have figured out the issue.

RE: examples of simple peripheral/central ble transmission nrf52 series

AHaug — Thu, 07 Jul 2022 12:29:07 GMT

Hi,

I will see if I can look into this error before the weekend, but I can not guarantee it as a we're running with a reduced staff in July due to the primary summer vacation period in Norway.

In the mean while: How far did you go in the hands on exercise? And did you use the same SDK version that the hands on uses?

[quote user="loganmeyer3"]after much experimenting I seem to be getting this error from the second example[/quote]

Also for errors like this you can do some investigating with arm-none-eabi-addr2line:

Check if you have arm-none-eabi-addr2line set up by running "where arm-none-eabi-addr2line" in a cmd window.
1. This should return something like "C:\Program Files (x86)\GNU Tools ARM Embedded\4.9 2015q3\bin\arm-none-eabi-addr2line.exe"
2. If it does not return this, then there might be some issues with the gnuarmemb path configuration
Next step is to investigate what is in the R15/pc and R14/lr addresses
1. arm-none-eabi-addr2line -e <path to _build\zephyr\zephyr.elf> <0x000211a8> for r15/pc
2. arm-none-eabi-addr2line -e <path to _build\zephyr\zephyr.elf> <0x00018b3d> for r14/lr

2. Should give you what function call that causes the kernel panic deep down in the stack. Remember to replace "<path to _build\zephyr\zephyr.elf>" with your actual path

Kind regards,
Andreas

RE: examples of simple peripheral/central ble transmission nrf52 series

loganmeyer3 — Wed, 06 Jul 2022 23:13:26 GMT

attached main and header below here is my prj.conf

RE: examples of simple peripheral/central ble transmission nrf52 series

loganmeyer3 — Wed, 06 Jul 2022 23:12:26 GMT

#include "remote.h"

#define BT_UUID_MY_SERVICE      BT_UUID_DECLARE_128(MY_SERVICE_UUID)
#define BT_UUID_MY_SERVICE_RX   BT_UUID_DECLARE_128(RX_CHARACTERISTIC_UUID)
#define BT_UUID_MY_SERVICE_TX   BT_UUID_DECLARE_128(TX_CHARACTERISTIC_UUID)

#define MAX_TRANSMIT_SIZE 240//TODO figure this out

uint8_t data_rx[MAX_TRANSMIT_SIZE];
uint8_t data_tx[MAX_TRANSMIT_SIZE];

int my_service_init(void)
{
    int err = 0;

    memset(&data_rx, 0, MAX_TRANSMIT_SIZE);
    memset(&data_tx, 0, MAX_TRANSMIT_SIZE);

    return err;
}

/* This function is called whenever the RX Characteristic has been written to by a Client */
static ssize_t on_receive(struct bt_conn *conn,
			  const struct bt_gatt_attr *attr,
			  const void *buf,
			  uint16_t len,
			  uint16_t offset,
			  uint8_t flags)
{
    const uint8_t * buffer = buf;
    
	printk("Received data, handle %d, conn %p, data: 0x", attr->handle, conn);
    for(uint8_t i = 0; i < len; i++){
        printk("%02X", buffer[i]);
    }
    printk("\n");

	return len;
}

/* This function is called whenever a Notification has been sent by the TX Characteristic */
static void on_sent(struct bt_conn *conn, void *user_data)
{
	ARG_UNUSED(user_data);

    const bt_addr_le_t * addr = bt_conn_get_dst(conn);
        
	printk("Data sent to Address 0x %02X %02X %02X %02X %02X %02X \n", addr->a.val[0]
                                                                    , addr->a.val[1]
                                                                    , addr->a.val[2]
                                                                    , addr->a.val[3]
                                                                    , addr->a.val[4]
                                                                    , addr->a.val[5]);
}

/* This function is called whenever the CCCD register has been changed by the client*/
void on_cccd_changed(const struct bt_gatt_attr *attr, uint16_t value)
{
    ARG_UNUSED(attr);
    switch(value)
    {
        case BT_GATT_CCC_NOTIFY: 
            // Start sending stuff!
            break;

        case BT_GATT_CCC_INDICATE: 
            // Start sending stuff via indications
            break;

        case 0: 
            // Stop sending stuff
            break;
        
        default: 
            printk("Error, CCCD has been set to an invalid value");     
    }
}
                        

/* LED Button Service Declaration and Registration */
BT_GATT_SERVICE_DEFINE(my_service,
BT_GATT_PRIMARY_SERVICE(BT_UUID_MY_SERVICE),
BT_GATT_CHARACTERISTIC(BT_UUID_MY_SERVICE_RX,
			       BT_GATT_CHRC_WRITE | BT_GATT_CHRC_WRITE_WITHOUT_RESP,
			       BT_GATT_PERM_READ | BT_GATT_PERM_WRITE, 
                   NULL, on_receive, NULL),
BT_GATT_CHARACTERISTIC(BT_UUID_MY_SERVICE_TX,
			       BT_GATT_CHRC_NOTIFY,
			       BT_GATT_PERM_READ,
                   NULL, NULL, NULL),
BT_GATT_CCC(on_cccd_changed,
        BT_GATT_PERM_READ | BT_GATT_PERM_WRITE),
);

/* This function sends a notification to a Client with the provided data,
given that the Client Characteristic Control Descripter has been set to Notify (0x1).
It also calls the on_sent() callback if successful*/
void my_service_send(struct bt_conn *conn, const uint8_t *data, uint16_t len)
{
    /* 
    The attribute for the TX characteristic is used with bt_gatt_is_subscribed 
    to check whether notification has been enabled by the peer or not.
    Attribute table: 0 = Service, 1 = Primary service, 2 = RX, 3 = TX, 4 = CCC.
    */
    const struct bt_gatt_attr *attr = &my_service.attrs[3]; 

    struct bt_gatt_notify_params params = 
    {
        .uuid   = BT_UUID_MY_SERVICE_TX,
        .attr   = attr,
        .data   = data,
        .len    = len,
        .func   = on_sent
    };

    // Check whether notifications are enabled or not
    if(bt_gatt_is_subscribed(conn, attr, BT_GATT_CCC_NOTIFY)) 
    {
        // Send the notification
	    if(bt_gatt_notify_cb(conn, &params))
        {
            printk("Error, unable to send notification\n");
        }
    }
    else
    {
        printk("Warning, notification not enabled on the selected attribute\n");
    }
}

RE: examples of simple peripheral/central ble transmission nrf52 series

loganmeyer3 — Wed, 06 Jul 2022 23:11:35 GMT

///main file
/*
 * Copyright (c) 2012-2014 Wind River Systems, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <zephyr.h>
#include <logging/log.h>
#include <dk_buttons_and_leds.h>
#include "remote.h"


#define DEVICE_NAME             CONFIG_BT_DEVICE_NAME
#define DEVICE_NAME_LEN         (sizeof(DEVICE_NAME) - 1)

static K_SEM_DEFINE(ble_init_ok, 0, 1);

static const struct bt_data ad[] = 
{
	BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
	BT_DATA(BT_DATA_NAME_COMPLETE, DEVICE_NAME, DEVICE_NAME_LEN),
};

static const struct bt_data sd[] = 
{
	BT_DATA_BYTES(BT_DATA_UUID128_ALL, MY_SERVICE_UUID),
};

struct bt_conn *my_connection;

static void connected(struct bt_conn *conn, uint8_t err)
{
	struct bt_conn_info info; 
	char addr[BT_ADDR_LE_STR_LEN];

	my_connection = conn;

	if (err) 
	{
		printk("Connection failed (err %u)\n", err);
		return;
	}
	else if(bt_conn_get_info(conn, &info))
	{
		printk("Could not parse connection info\n");
	}
	else
	{
		bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
		
		printk("Connection established!		\n\
		Connected to: %s					\n\
		Role: %u							\n\
		Connection interval: %u				\n\
		Slave latency: %u					\n\
		Connection supervisory timeout: %u	\n"
		, addr, info.role, info.le.interval, info.le.latency, info.le.timeout);
	}
}

static void disconnected(struct bt_conn *conn, uint8_t reason)
{
	printk("Disconnected (reason %u)\n", reason);
}

static bool le_param_req(struct bt_conn *conn, struct bt_le_conn_param *param)
{
	//If acceptable params, return true, otherwise return false.
	return true; 
}

static void le_param_updated(struct bt_conn *conn, uint16_t interval, uint16_t latency, uint16_t timeout)
{
	struct bt_conn_info info; 
	char addr[BT_ADDR_LE_STR_LEN];
	
	if(bt_conn_get_info(conn, &info))
	{
		printk("Could not parse connection info\n");
	}
	else
	{
		bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
		
		printk("Connection parameters updated!	\n\
		Connected to: %s						\n\
		New Connection Interval: %u				\n\
		New Slave Latency: %u					\n\
		New Connection Supervisory Timeout: %u	\n"
		, addr, info.le.interval, info.le.latency, info.le.timeout);
	}
}

static struct bt_conn_cb conn_callbacks = 
{
	.connected				= connected,
	.disconnected   		= disconnected,
	.le_param_req			= le_param_req,
	.le_param_updated		= le_param_updated
};

static void bt_ready(int err)
{
	if (err) 
	{
		printk("BLE init failed with error code %d\n", err);
		return;
	}

	//Configure connection callbacks
	bt_conn_cb_register(&conn_callbacks);

	//Initalize services
	err = my_service_init();

	if (err) 
	{
		printk("Failed to init LBS (err:%d)\n", err);
		return;
	}

	//Start advertising
	err = bt_le_adv_start(BT_LE_ADV_CONN, ad, ARRAY_SIZE(ad),
			      sd, ARRAY_SIZE(sd));
	if (err) 
	{
		printk("Advertising failed to start (err %d)\n", err);
		return;
	}

	printk("Advertising successfully started\n");

	k_sem_give(&ble_init_ok);
}


static void error(void)
{
	while (true) {
		printk("Error!\n");
		/* Spin for ever */
		k_sleep(K_MSEC(1000)); //1000ms
	}
}

void main(void)
{
	
	int err = 0;
	uint32_t number = 0;

	printk("Starting Nordic BLE peripheral tutorial\n");

	
	err = bt_enable(bt_ready);

	if (err) 
	{
		printk("BLE initialization failed\n");
		error(); //Catch error
	}
	
	/* 	Bluetooth stack should be ready in less than 100 msec. 								\
																							\
		We use this semaphore to wait for bt_enable to call bt_ready before we proceed 		\
		to the main loop. By using the semaphore to block execution we allow the RTOS to 	\
		execute other tasks while we wait. */	
	err = k_sem_take(&ble_init_ok, K_MSEC(500));

	if (!err) 
	{
		printk("Bluetooth initialized\n");
	} else 
	{
		printk("BLE initialization did not complete in time\n");
		error(); //Catch error
	}

	err = my_service_init();

	for (;;) 
	{
		// Main loop
		my_service_send(my_connection, (uint8_t *)&number, sizeof(number));
		number++;
		k_sleep(K_MSEC(1000)); // 1000ms
	}
}

RE: examples of simple peripheral/central ble transmission nrf52 series

loganmeyer3 — Wed, 06 Jul 2022 23:11:04 GMT

////this is .h

#include <zephyr.h>
#include <logging/log.h>

#include <bluetooth/bluetooth.h>
#include <bluetooth/uuid.h>
#include <bluetooth/gatt.h>
#include <bluetooth/hci.h>

#define MY_SERVICE_UUID 0xd4, 0x86, 0x48, 0x24, 0x54, 0xB3, 0x43, 0xA1, \
			            0xBC, 0x20, 0x97, 0x8F, 0xC3, 0x76, 0xC2, 0x75

#define RX_CHARACTERISTIC_UUID  0xA6, 0xE8, 0xC4, 0x60, 0x7E, 0xAA, 0x41, 0x6B, \
			                    0x95, 0xD4, 0x9D, 0xCC, 0x08, 0x4F, 0xCF, 0x6A

#define TX_CHARACTERISTIC_UUID  0xED, 0xAA, 0x20, 0x11, 0x92, 0xE7, 0x43, 0x5A, \
			                    0xAA, 0xE9, 0x94, 0x43, 0x35, 0x6A, 0xD4, 0xD3

/** @brief Callback type for when new data is received. */
typedef void (*data_rx_cb_t)(uint8_t *data, uint8_t length);

/** @brief Callback struct used by the my_service Service. */
struct my_service_cb 
{
	/** Data received callback. */
	data_rx_cb_t    data_rx_cb;
};

int my_service_init(void);

void my_service_send(struct bt_conn *conn, const uint8_t *data, uint16_t len);

RE: examples of simple peripheral/central ble transmission nrf52 series

loganmeyer3 — Wed, 06 Jul 2022 23:09:16 GMT

after much experimenting I seem to be getting this error from the second example.

RE: examples of simple peripheral/central ble transmission nrf52 series

AHaug — Fri, 24 Jun 2022 07:00:56 GMT

Hi,

Yes, you may keep this ticket open if you would like so for follow up questions which are related to the topic in this ticket. If you have new questions, I will of course try to reply and answer to them, but I would recommend to create new tickets for unique questions and cases.

And also yes, I would say this type of ticket is something that is perfect as a public ticket as there are very likely more out there with the same questions and in the same situation, so go ahead and convert it if you're comfortable with that!

Kind regards,
Andreas

RE: examples of simple peripheral/central ble transmission nrf52 series

loganmeyer3 — Thu, 23 Jun 2022 14:38:15 GMT

after quick skim this is very nice i will study all. thank you for your help. Can I keep this case open for a few days if I have anymore questions? Also i am not sure why this is private but I am happy for this to be public if it helps other people.

RE: examples of simple peripheral/central ble transmission nrf52 series

AHaug — Thu, 23 Jun 2022 14:30:30 GMT

Hi,
No worries at all, I will do my best to help you progress with the issues you're struggling with and explain how to create custom services

[quote user="loganmeyer3"]I have already gone through that course[/quote]

Great to hear!

[quote user="loganmeyer3"] I have focused on central and peripheral example and have focused on uart central and peripheral example.[/quote]

I was thinking you had focused the zephyr/samples/bluetooth/central and peripheral and not ...nrf/samples/bluetooth/central_uart and peripheral_uart samples (there is a slight difference there), but if you've already examined them, then lets move on a bit.

1) This course, should teach you everything you need to know about how to create your own services in NCS. Please not that this is not a tutorial or guide which and it is not maintained as it is not public, but rather a course developed to demonstrate how to create your own remote controller for students. The hands on is quite tedious w.r.t step by step, but I found it very handy when learning about custom services my self. You can also skip the parts which contains pwm motor control without any issues as long as you make the corresponding changes in the cmakelists and in main. The course also contains partial solutions in zips which you can download and compare/use in case you are stuck on the hands on.

2) This guide, which is slightly old (ncs v1.2) but it should translate pretty good into NCS today, sheds some light on how to create your own custom services.

I will try to dig up some more material, but in the meanwhile (if you have time) you could examine those resources1)

Kind regards,
andreas

RE: examples of simple peripheral/central ble transmission nrf52 series

loganmeyer3 — Thu, 23 Jun 2022 13:45:10 GMT

Thanks Andreas, I have already gone through that course and have looked at the majority of the examples provided by nrf connect. I have focused on central and peripheral example and have focused on uart central and peripheral example. I know I am a slow learner but I have been studying this for 8 hrs a day for the past almost 3 weeks. I understand the NUS service but I fail to understand how to make a custom service from custom uuid and send individual bytes of data in array format. I apologize for my ignorance, I am just greatly struggling.

RE: examples of simple peripheral/central ble transmission nrf52 series

AHaug — Thu, 23 Jun 2022 13:26:05 GMT

Hi,

I would recommend you take a look at the nrf samples in nRF Connect for Desktop, more specifically central_uart and peripheral_uart that uses Nordic UART Service (NUS) Client. They uses the NUS service to send data back and forth between a UART connection and a Bluetooth® LE connection. The samples available in our SDK are a great starting point for examining various concepts.

Also, in case you have not gotten started with the nRF Connect SDK, this course is another great starting point.

Kind regards,
Andreas