CC2540/CC2541 : Change Scan Response Data( SRP) dynamically

     How to change the SRP data is a very imperative for most bluetooth low energy use case. But in official Texas Instruments(TI) example code, there is no demonstration  for this purpose. In here, I note how to reach the goal.

    In the TI forum , it sai possible to update RSP data by disabling/enabling advertising.  But for my feeble trying, the RSP do not be updated. So I use the "reboot" as my method.

   Before achieving the topic goal, I would like to refer to how to add uart receiving function in example SimpleBLEPeripheral. The is based on ghostyu's example (in simplified chinese).


0. Copy while SimpleBLEPeripheral folder as a new folder SimpleBLEPeripheral_SerialPrint.

1. Add those file in your IAR project:

serialcommunication.c :

#include "bcomdef.h"
#include "OSAL.h"
#include "OSAL_PwrMgr.h"

#include "OnBoard.h"
#include "hal_uart.h"
#include "hal_lcd.h"
#include "serialcommunication.h"

#if defined ( PLUS_BROADCASTER )
  #include "peripheralBroadcaster.h"
#else
  #include "peripheral.h"
#endif

void SerialInitTransport(void)
{
  halUARTCfg_t uartConfig;

  // configure UART
  uartConfig.configured           = TRUE;
  uartConfig.baudRate             = SBP_UART_BR;
  uartConfig.flowControl          = SBP_UART_FC;
  uartConfig.flowControlThreshold = SBP_UART_FC_THRESHOLD;//enable when flowControl is valid
  uartConfig.rx.maxBufSize        = SBP_UART_RX_BUF_SIZE;//UART RX 
  uartConfig.tx.maxBufSize        = SBP_UART_TX_BUF_SIZE;//UART TX
  uartConfig.idleTimeout          = SBP_UART_IDLE_TIMEOUT;
  uartConfig.intEnable            = SBP_UART_INT_ENABLE;//interrupt enable
  uartConfig.callBackFunc         = sbpSerialAppCallback;//uart callback function

  // start UART
  // Note: Assumes no issue opening UART port.
  (void)HalUARTOpen( SBP_UART_PORT, &uartConfig );

  return;
}/*serialAppInitTransport*/


uint16 numBytes;

void sbpSerialAppCallback(uint8 port, uint8 event)
{
  uint8  pktBuffer[SBP_UART_RX_BUF_SIZE];
  // unused input parameter; PC-Lint error 715.
  (void)event;
  HalLcdWriteString("Data form my UART:", HAL_LCD_LINE_4 );
  //return lengh
  if( (numBytes = Hal_UART_RxBufLen(port)) > 0)
  {      
      //int j;
        //read all data
 (void)HalUARTRead(port, pktBuffer, numBytes);
        //uint8 blankStr[HAL_LCD_MAX_CHARS];
       // memset(&blankStr[0], 32, HAL_LCD_MAX_CHARS);
                      
 HalLcdWriteString(pktBuffer, HAL_LCD_LINE_5 );
        
        //GAPRole_SetParameter( GAPROLE_SCAN_RSP_DATA, 
        //  numBytes, &pktBuffer[0] );
        
        //simpleProfileChar1 = pktBuffer[0];
  }/*if */
  
}/*sbpSerialAppCallback*/


static uint8 sendMsgTo_TaskID;

void SerialApp_Init( uint8 taskID )
{
  SerialInitTransport(); 
  sendMsgTo_TaskID = taskID; //save task id, for spare using.
}/*SerialApp_Init*/

serialcommunication.h

#ifndef _SERIAL_COMMUNICATION_H_
#define _SERIAL_COMMUNICATION_H_

#ifdef __cplusplus
extern "C"
{
#endif
  

#define SBP_UART_PORT                  HAL_UART_PORT_0
//#define SBP_UART_FC                    TRUE
#define SBP_UART_FC                    FALSE
#define SBP_UART_FC_THRESHOLD          48
#define SBP_UART_RX_BUF_SIZE           128
#define SBP_UART_TX_BUF_SIZE           128
#define SBP_UART_IDLE_TIMEOUT          6
#define SBP_UART_INT_ENABLE            TRUE
#define SBP_UART_BR                     HAL_UART_BR_57600 


// Serial Port Related
extern void SerialApp_Init(uint8 taskID);
extern void sbpSerialAppCallback(uint8 port, uint8 event);
void SerialInitTransport();

#ifdef __cplusplus
}
#endif

#endif/*_SERIAL_COMMUNICATION_H_*/

3. Modify simpleBLEPeripheral.c :

Add include  (about line 82):

#if defined FEATURE_OAD
  #include "oad.h"
  #include "oad_target.h"
#endif

#include "serialcommunication.h"
/*********************************************************************
 * MACROS
 */

Initialize uart (in function void SimpleBLEPeripheral_Init( uint8 task_id ), about line 286):

void SimpleBLEPeripheral_Init( uint8 task_id )
{
  simpleBLEPeripheral_TaskID = task_id;

  SerialApp_Init(task_id);
  // Setup the GAP

Now, you could use a serial com-port program(like sscom) to send data via uart.


    I assume the new SRP data is from UART, and received data be only the new SRP string. Modifying the UART callback function, to add some processing for save RSP values:

uint16 numBytes;

void sbpSerialAppCallback(uint8 port, uint8 event)
{
  uint8 pktBuffer[SBP_UART_RX_BUF_SIZE];
  // unused input parameter; PC-Lint error 715.
  (void)event;
  HalLcdWriteString("Data form my UART:", HAL_LCD_LINE_4 );
  
  //return length
  if( 0 < (numBytes = Hal_UART_RxBufLen(port)))
  {      
    
 /*that should use timer + process_event to update LCD content*/   
    //(void)HalUARTRead(port, pktBuffer, numBytes);        
 
 /* 
  baud rate = 57600-> byterate = 7200, it is, for one byte,  it needs 138 us 
  nop cast 1 clock, for CC254X, the crytal be 32MHz
  it is needed to be dalay over 138us ->  4416 nop operations
  
  if there is no delay in here, the uart-in data would be lost.
  
  most persons use 6000 (192us) as delay constant (a superstition?)
 */
    int i = 0;
    for(i = 0 ;0 < 6000;i++) 
  asm("nop");
  
  
 /*string sequence may be ended at 0x0A(enter) 0x0D(new line)*/
    if(0x0A == pData[numBytes - 1] || 0x0D == pData[numBytes - 1])
  numBytes--;
        
 if(0x0A == pData[numBytes - 2] || 0x0D == pData[numBytes - 2])
  numBytes--; 
 
        uint8 buffer[32];
        uint16 scanRspDataSize;
        
        memset(&buffer[0], 0, 32);                

        osal_snv_write(NV_MEM_ID, 32, &buffer[0]);
        
        SetRspData(&pData[0], numBytes, &buffer[0], &scanRspDataSize);              
        osal_snv_write(NV_MEM_ID, scanRspDataSize, &buffer[0]);                                  
        HAL_SYSTEM_RESET();          
  }/*if */
  
}/*sbpSerialAppCallback*/

  that is,clean the non-volatile memory, and save the organized RSP data, then reboot.

the NV_MEM_ID is 0xFE, it is my choice only. you could use other value.

the SetRspData function, which is for organizing data as RSP format, be :
(I wrote it in simpleBLEPeripheral.c)

void SetRspData(uint8 *pName, uint16 nameLen, 
                uint8 *pRspData, uint16 *pScanRspDataSize)
{       

  if(nameLen  > 31 - (2 + (5 + 1) + (1 + 2)) )
    nameLen =  31 - (2 + (5 + 1) + (1 + 2));
    
  pRspData[0] = nameLen + 1;
  pRspData[1] = GAP_ADTYPE_LOCAL_NAME_COMPLETE;
  memcpy(&pRspData[2], pName, nameLen); 
 
  int16  i;
  
  i = nameLen + 2; 
  pRspData[i++] = 0x05;
  pRspData[i++] = GAP_ADTYPE_SLAVE_CONN_INTERVAL_RANGE;
  pRspData[i++] = LO_UINT16( DEFAULT_DESIRED_MIN_CONN_INTERVAL );     
  pRspData[i++] = HI_UINT16( DEFAULT_DESIRED_MIN_CONN_INTERVAL );
  pRspData[i++] = LO_UINT16( DEFAULT_DESIRED_MAX_CONN_INTERVAL );     
  pRspData[i++] = HI_UINT16( DEFAULT_DESIRED_MAX_CONN_INTERVAL );
  
  pRspData[i++] = 0x02;
  pRspData[i++] =GAP_ADTYPE_POWER_LEVEL;
  pRspData[i++] = 0;       // 0dBm;    
  
  *pScanRspDataSize =  i;
}/*SetRspData*/

Now modify the void SimpleBLEPeripheral_Init( uint8 task_id ) in simpleBLEPeripheral.c, about line 315 :

 // Set the GAP Role Parameters    
    
    GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &initial_advertising_enable );
    GAPRole_SetParameter( GAPROLE_ADVERT_OFF_TIME, sizeof( uint16 ), &gapRole_AdvertOffTime );
       
    uint8 defaultName[32];
    
    memset(&defaultName[0], 0, 32);
    sprintf((char*)&defaultName[0], "defaultRSP");
    
    uint8 buffer[32];    
    memset(&buffer[0], 0, 32);
      
    uint8 ret;       
   
    uint16 scanRspDataSize;
    scanRspDataSize = 0;  

    ret = osal_snv_read(NV_MEM_ID, 32 , &buffer[0]);
   
    if(SUCCESS == ret )  
    {      
      int i;      
      scanRspDataSize = 0;       
      scanRspDataSize = 1 + buffer[0];      
      i = 1 + buffer[0];
      scanRspDataSize += 1 + buffer[i];
      i += 1 + buffer[i];      
      scanRspDataSize += 1 + buffer[i];
    }/*if*/    
    
    if(NV_OPER_FAILED == ret)
    {
      memset(&buffer[0], 0, 31);      
      SetRspData(&defaultName[0], strlen((char*)&defaultName[0]), 
                 &buffer[0], &scanRspDataSize);      
      //ret = osal_snv_read(0xfe, 32 , &buffer[0]);
      //osal_snv_write(0xfe, sizeof(scanRspData), &scanRspData[0]);
    }/*if */
       
    
    GAPRole_SetParameter( GAPROLE_SCAN_RSP_DATA, scanRspDataSize, &buffer[0] );

That is, to read the non-volatile memory: if there is no data, use default name, otherwise use saved data. That data would be used for SRP, the peripheral name.


If you use serial comport program to send a string into the CC2540 (or CC2541), the board would reboot, and the string be the new peripheral name.

Extra:

If you would like to print data to uart (that could use for echoing), the serialcommunication.c could be add function SerialPrintf :

// ref : http://bbs.elecfans.com/jishu_431223_2_1.html#comment_top

#ifdef HAL_UART_DMA_TX_MAX
  #define PRINT_BUF_LEN HAL                 UART_DMA_TX_MAX
#else
  #define PRINT_BUF_LEN                     (128)
#endif

int SerialPrintf(const char *fmt, ...)
{
    uint32  ulLen;
    va_list ap;

    char *pBuf;
    
    pBuf = (char*)osal_mem_alloc(PRINT_BUF_LEN);  
    
    va_start(ap, fmt);
    ulLen = vsprintf(pBuf, fmt, ap);       
    va_end(ap);

    HalUARTWrite(HAL_UART_PORT_0, (uint8*)pBuf, ulLen); 
    osal_mem_free(pBuf);    
    
    return ulLen;    
}/*SerialPrintf*/

And do not forget adding include head to avoid compiling warning.

#include "stdarg.h"
#include "stdio.h"