int btstack_main(int argc, const char * argv[]){
// init L2CAP
l2cap_init();
l2cap_register_packet_handler(packet_handler);
// init RFCOMM
rfcomm_init();
rfcomm_register_packet_handler(packet_handler);
rfcomm_register_service_with_initial_credits_internal(NULL, rfcomm_channel_nr, 0xffff, 1); // reserved channel, mtu limited by l2cap, 1 credit
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
service_record_item_t * service_record_item = (service_record_item_t *) spp_service_buffer;
sdp_create_spp_service( (uint8_t*) &service_record_item->service_record, 1, "SPP Counter");
printf("SDP service buffer size: %u\n\r", (uint16_t) (sizeof(service_record_item_t) + de_get_len((uint8_t*) &service_record_item->service_record)));
sdp_register_service_internal(NULL, service_record_item);
// set one-shot timer
heartbeat.process = &heartbeat_handler;
run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
run_loop_add_timer(&heartbeat);
puts("SPP FlowControl Demo: simulates processing on received data...\n\r");
gap_set_local_name("BTstack SPP Flow Control");
hci_discoverable_control(1);
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
int btstack_main(int argc, const char * argv[]){
(void)argc;
(void)argv;
// register for HCI events
hci_event_callback_registration.callback = &packet_handler;
hci_add_event_handler(&hci_event_callback_registration);
hci_register_sco_packet_handler(&packet_handler);
gap_discoverable_control(1);
gap_set_class_of_device(0x2540);
gap_set_local_name("HID Mouse Demo 00:00:00:00:00:00");
// L2CAP
l2cap_init();
// SDP Server
sdp_init();
memset(hid_service_buffer, 0, sizeof(hid_service_buffer));
// hid sevice subclass 2540 Keyboard, hid counntry code 33 US, hid virtual cable off, hid reconnect initiate off, hid boot device off
hid_create_sdp_record(hid_service_buffer, 0x10001, 0x2540, 33, 0, 0, 0, hid_descriptor_mouse_boot_mode, sizeof(hid_descriptor_mouse_boot_mode), hid_device_name);
printf("SDP service record size: %u\n", de_get_len( hid_service_buffer));
sdp_register_service(hid_service_buffer);
// HID Device
hid_device_init();
hid_device_register_packet_handler(&packet_handler);
#ifdef HAVE_BTSTACK_STDIN
btstack_stdin_setup(stdin_process);
#endif
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
int btstack_main(void){
// init L2CAP
l2cap_init();
l2cap_register_packet_handler(packet_handler);
// init RFCOMM
rfcomm_init();
rfcomm_register_packet_handler(packet_handler);
rfcomm_register_service_internal(NULL, rfcomm_channel_nr, 100); // reserved channel, mtu=100
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
service_record_item_t * service_record_item = (service_record_item_t *) spp_service_buffer;
sdp_create_spp_service( (uint8_t*) &service_record_item->service_record, 1, "SPP Counter");
printf("SDP service buffer size: %u\n\r", (uint16_t) (sizeof(service_record_item_t) + de_get_len((uint8_t*) &service_record_item->service_record)));
sdp_register_service_internal(NULL, service_record_item);
// set one-shot timer
heartbeat.process = &timer_handler;
run_loop_register_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
printf("Run...\n\r");
// turn on!
hci_power_control(HCI_POWER_ON);
// go!
run_loop_execute();
// happy compiler!
return 0;
}
int btstack_main(int argc, const char * argv[]){
hci_set_sco_voice_setting(0x0060); // PCM, 16 bit, 2's complement, MSB Position 0,
setup_audio();
hci_register_sco_packet_handler(&sco_packet_handler);
memset((uint8_t *)hsp_service_buffer, 0, sizeof(hsp_service_buffer));
hsp_hs_create_service((uint8_t *)hsp_service_buffer, rfcomm_channel_nr, hsp_hs_service_name, 0);
hsp_hs_init(rfcomm_channel_nr);
hsp_hs_register_packet_handler(packet_handler);
sdp_init();
sdp_register_service_internal(NULL, (uint8_t *)hsp_service_buffer);
hci_discoverable_control(1);
hci_set_class_of_device(0x200418);
btstack_stdin_setup(stdin_process);
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
int __sdp_connect(char *target)
{
int status;
struct sockaddr_affix sa;
status = sdp_init(0);
if (status < 0)
return status;
sa.family = PF_AFFIX;
sa.devnum = hci_devnum(btdev);//HCIDEV_ANY;
if (strcmp(target, "local") == 0) {
printf("Opening local connection\n");
srvHandle = sdp_connect_local();
} else {
status = btdev_get_bda(&sa.bda, target);
if (status) {
printf("Incorrect address given\n");
return -1;
}
printf("Connecting to host %s ...\n", bda2str(&sa.bda));
srvHandle = sdp_connect(&sa);
}
if (srvHandle < 0)
return -1;
return 0;
}
int btstack_main(int argc, const char * argv[]){
/* Initialize L2CAP */
l2cap_init();
l2cap_register_packet_handler(packet_handler);
/* Initialise BNEP */
bnep_init();
bnep_register_packet_handler(packet_handler);
bnep_register_service(NULL, bnep_local_service_uuid, 1691); /* Minimum L2CAP MTU for bnep is 1691 bytes */
/* Initialize SDP and add PANU record */
sdp_init();
uint16_t network_packet_types[] = { NETWORK_TYPE_IPv4, NETWORK_TYPE_ARP, 0}; // 0 as end of list
#ifdef EMBEDDED
service_record_item_t * service_record_item = (service_record_item_t *) panu_sdp_record;
pan_create_panu_service((uint8_t*) &service_record_item->service_record, network_packet_types, NULL, NULL, BNEP_SECURITY_NONE);
printf("SDP service buffer size: %u\n", (uint16_t) (sizeof(service_record_item_t) + de_get_len((uint8_t*) &service_record_item->service_record)));
sdp_register_service_internal(NULL, service_record_item);
#else
pan_create_panu_service(panu_sdp_record, network_packet_types, NULL, NULL, BNEP_SECURITY_NONE);
printf("SDP service record size: %u\n", de_get_len((uint8_t*) panu_sdp_record));
sdp_register_service_internal(NULL, (uint8_t*)panu_sdp_record);
#endif
/* Turn on the device */
hci_power_control(HCI_POWER_ON);
hci_discoverable_control(1);
btstack_stdin_setup(stdin_process);
return 0;
}
/* LISTING_START(SPPSetup): SPP service setup */
void spp_service_setup(){
l2cap_init();
l2cap_register_packet_handler(packet_handler);
rfcomm_init();
rfcomm_register_packet_handler(packet_handler);
rfcomm_register_service_internal(NULL, RFCOMM_SERVER_CHANNEL, 0xffff); // reserved channel, mtu limited by l2cap
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
/* LISTING_PAUSE */
#ifdef EMBEDDED
/* LISTING_RESUME */
service_record_item_t * service_record_item = (service_record_item_t *) spp_service_buffer;
sdp_create_spp_service( (uint8_t*) &service_record_item->service_record, RFCOMM_SERVER_CHANNEL, "SPP Counter");
printf("SDP service buffer size: %u\n", (uint16_t) (sizeof(service_record_item_t) + de_get_len((uint8_t*) &service_record_item->service_record)));
sdp_register_service_internal(NULL, service_record_item);
/* LISTING_PAUSE */
#else
sdp_create_spp_service( spp_service_buffer, RFCOMM_SERVER_CHANNEL, "SPP Counter");
printf("SDP service record size: %u\n", de_get_len(spp_service_buffer));
sdp_register_service_internal(NULL, spp_service_buffer);
#endif
/* LISTING_RESUME */
}
void setup(void){
/// GET STARTED with BTstack ///
btstack_memory_init();
run_loop_init(RUN_LOOP_POSIX);
// use logger: format HCI_DUMP_PACKETLOGGER, HCI_DUMP_BLUEZ or HCI_DUMP_STDOUT
hci_dump_open("/tmp/hci_dump.pklg", HCI_DUMP_PACKETLOGGER);
// init HCI
hci_transport_t * transport = hci_transport_usb_instance();
hci_uart_config_t * config = NULL;
bt_control_t * control = NULL;
remote_device_db_t * remote_db = (remote_device_db_t *) &remote_device_db_memory;
hci_init(transport, config, control, remote_db);
hci_discoverable_control(1);
l2cap_init();
l2cap_register_packet_handler(packet_handler);
rfcomm_init();
rfcomm_register_packet_handler(packet_handler);
rfcomm_register_service_internal(NULL, RFCOMM_SERVER_CHANNEL, 100); // reserved channel, mtu=100
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
// service_record_item_t * service_record_item = (service_record_item_t *) spp_service_buffer;
// sdp_create_spp_service( (uint8_t*) &service_record_item->service_record, RFCOMM_SERVER_CHANNEL, "SPP Counter");
// printf("SDP service buffer size: %u\n\r", (uint16_t) (sizeof(service_record_item_t) + de_get_len((uint8_t*) &service_record_item->service_record)));
// sdp_register_service_internal(NULL, service_record_item);
sdp_create_spp_service( spp_service_buffer, RFCOMM_SERVER_CHANNEL, "SPP Counter");
printf("SDP service record size: %u\n\r", de_get_len(spp_service_buffer));
sdp_register_service_internal(NULL, spp_service_buffer);
}
int btstack_main(int argc, const char * argv[]){
/* Register for HCI events */
hci_event_callback_registration.callback = &packet_handler;
hci_add_event_handler(&hci_event_callback_registration);
/* Initialize L2CAP */
l2cap_init();
/* Initialise BNEP */
bnep_init();
bnep_register_service(&packet_handler, bnep_local_service_uuid, 1691); /* Minimum L2CAP MTU for bnep is 1691 bytes */
/* Initialize SDP and add PANU record */
sdp_init();
uint16_t network_packet_types[] = { NETWORK_TYPE_IPv4, NETWORK_TYPE_ARP, 0}; // 0 as end of list
pan_create_panu_sdp_record(panu_sdp_record, 0x10002, network_packet_types, NULL, NULL, BNEP_SECURITY_NONE);
printf("SDP service record size: %u\n", de_get_len((uint8_t*) panu_sdp_record));
sdp_register_service((uint8_t*)panu_sdp_record);
/* Turn on the device */
hci_power_control(HCI_POWER_ON);
gap_discoverable_control(1);
btstack_stdin_setup(stdin_process);
return 0;
}
static void init_everything(void) {
log_init("rtpengine");
log_format(rtpe_config.log_format);
recording_fs_init(rtpe_config.spooldir, rtpe_config.rec_method, rtpe_config.rec_format);
rtpe_ssl_init();
#if !GLIB_CHECK_VERSION(2,32,0)
g_thread_init(NULL);
#endif
#if !(GLIB_CHECK_VERSION(2,36,0))
g_type_init();
#endif
signals();
resources();
sdp_init();
dtls_init();
ice_init();
crypto_init_main();
interfaces_init(&rtpe_config.interfaces);
iptables_init();
control_ng_init();
if (call_interfaces_init())
abort();
statistics_init();
codeclib_init(0);
media_player_init();
}
int btstack_main(int argc, const char * argv[]){
UNUSED(argc);
(void)argv;
/* Register for HCI events */
hci_event_callback_registration.callback = &packet_handler;
hci_add_event_handler(&hci_event_callback_registration);
l2cap_init();
// Initialize AVRCP COntroller
avrcp_controller_init();
avrcp_controller_register_packet_handler(&packet_handler);
// Initialize SDP
sdp_init();
memset(sdp_avrcp_controller_service_buffer, 0, sizeof(sdp_avrcp_controller_service_buffer));
avrcp_controller_create_sdp_record(sdp_avrcp_controller_service_buffer, 0x10001, AVRCP_BROWSING_ENABLED, 1, NULL, NULL);
sdp_register_service(sdp_avrcp_controller_service_buffer);
gap_set_local_name("BTstack AVRCP Test");
gap_discoverable_control(1);
// gap_set_class_of_device(0x200408);
// parse human readable Bluetooth address
sscanf_bd_addr(device_addr_string, device_addr);
// turn on!
hci_power_control(HCI_POWER_ON);
#ifdef HAVE_BTSTACK_STDIN
btstack_stdin_setup(stdin_process);
#endif
return 0;
}
int btstack_main(int argc, const char * argv[]){
#ifdef TABLE_SIZE
compute_signal();
#endif
hci_register_sco_packet_handler(&sco_packet_handler);
hci_discoverable_control(1);
hci_ssp_set_io_capability(SSP_IO_CAPABILITY_DISPLAY_YES_NO);
gap_set_local_name("BTstack HSP HS");
hsp_hs_init(rfcomm_channel_nr);
hsp_hs_register_packet_handler(packet_handler);
sdp_init();
memset((uint8_t *)hsp_service_buffer, 0, sizeof(hsp_service_buffer));
hsp_hs_create_service((uint8_t *)hsp_service_buffer, rfcomm_channel_nr, hsp_hs_service_name, 0);
sdp_register_service_internal(NULL, (uint8_t *)hsp_service_buffer);
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
void bt_init ( void )
{
sys_init();
mem_init();
memp_init();
pbuf_init();
UART2PrintString("mem mgmt initialized\r\n");
lwbt_memp_init();
phybusif_init("");
cb = malloc(sizeof(struct phybusif_cb));
phybusif_reset(cb);
if(hci_init() != ERR_OK) {
UART2PrintString("HCI initialization failed!\r\n");
return;
}
l2cap_init();
sdp_init();
rfcomm_init();
UART2PrintString("Bluetooth initialized.\r\n");
bt_spp_start();
UART2PrintString("Applications started.\r\n");
}
int btstack_main(int argc, const char * argv[]){
// init L2CAP
l2cap_init();
l2cap_register_packet_handler(packet_handler);
// init RFCOMM
rfcomm_init();
rfcomm_register_packet_handler(packet_handler);
rfcomm_register_service_internal(NULL, rfcomm_channel_nr, 100); // reserved channel, mtu=100
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
service_record_item_t * service_record_item = (service_record_item_t *) spp_service_buffer;
sdp_create_spp_service( (uint8_t*) &service_record_item->service_record, 1, "SPP Counter");
printf("SDP service buffer size: %u\n\r", (uint16_t) (sizeof(service_record_item_t) + de_get_len((uint8_t*) &service_record_item->service_record)));
sdp_register_service_internal(NULL, service_record_item);
// set one-shot timer
timer_source_t heartbeat;
heartbeat.process = &heartbeat_handler;
run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
run_loop_add_timer(&heartbeat);
// set local name
gap_set_local_name("BlueMSP-Demo");
// make discoverable
hci_discoverable_control(1);
printf("Run...\n\r");
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
int btstack_main(int argc, const char * argv[]){
// init L2CAP
l2cap_init();
rfcomm_init();
hfp_ag_init(rfcomm_channel_nr);
hfp_ag_init_supported_features(0x3ef | (1<<HFP_AGSF_HF_INDICATORS) | (1<<HFP_AGSF_ESCO_S4));
hfp_ag_init_codecs(sizeof(codecs), codecs);
hfp_ag_init_ag_indicators(ag_indicators_nr, ag_indicators);
hfp_ag_init_hf_indicators(hf_indicators_nr, hf_indicators);
hfp_ag_init_call_hold_services(call_hold_services_nr, call_hold_services);
hfp_ag_set_subcriber_number_information(&subscriber_number, 1);
hfp_ag_register_packet_handler(packet_handler);
sdp_init();
// init SDP, create record for SPP and register with SDP
memset((uint8_t *)hfp_service_buffer, 0, sizeof(hfp_service_buffer));
hfp_ag_create_sdp_record((uint8_t *)hfp_service_buffer, rfcomm_channel_nr, hfp_ag_service_name, 0, 0);
sdp_register_service_internal(NULL, (uint8_t *)hfp_service_buffer);
// pre-select pts
memcpy(device_addr, pts_addr, 6);
// turn on!
hci_power_control(HCI_POWER_ON);
btstack_stdin_setup(stdin_process);
return 0;
}
static void BTAttached() {
btstack_memory_init();
// init HCI
hci_transport_t * transport = hci_transport_mchpusb_instance(bt_buf, bt_buf_size);
bt_control_t * control = NULL;
hci_uart_config_t * config = NULL;
const remote_device_db_t * remote_db = &remote_device_db_memory;
hci_init(transport, config, control, remote_db);
// init L2CAP
l2cap_init();
l2cap_register_packet_handler(PacketHandler);
// init RFCOMM
rfcomm_init();
rfcomm_register_packet_handler(PacketHandler);
rfcomm_register_service_internal(NULL, rfcomm_channel_nr, 100); // reserved channel, mtu=100
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof (spp_service_buffer));
service_record_item_t * service_record_item = (service_record_item_t *) spp_service_buffer;
sdp_create_spp_service((uint8_t*) & service_record_item->service_record, 1, "IOIO-App");
log_printf("SDP service buffer size: %u\n\r", (uint16_t) (sizeof (service_record_item_t) + de_get_len((uint8_t*) & service_record_item->service_record)));
sdp_register_service_internal(NULL, service_record_item);
hci_power_control(HCI_POWER_ON);
client_callback = DummyCallback;
}
int btstack_main(int argc, const char * argv[]){
// init L2CAP
l2cap_init();
rfcomm_init();
hfp_ag_init(rfcomm_channel_nr, 438, codecs, sizeof(codecs),
ag_indicators, ag_indicators_nr,
hf_indicators, hf_indicators_nr,
call_hold_services, call_hold_services_nr);
hfp_register_packet_handler(packet_handler);
sdp_init();
// init SDP, create record for SPP and register with SDP
memset((uint8_t *)hfp_service_buffer, 0, sizeof(hfp_service_buffer));
hfp_ag_create_service((uint8_t *)hfp_service_buffer, rfcomm_channel_nr, hfp_ag_service_name, 0, 0);
sdp_register_service_internal(NULL, (uint8_t *)hfp_service_buffer);
// turn on!
hci_power_control(HCI_POWER_ON);
btstack_stdin_setup(stdin_process);
printf("Establishing HFP connection to %s...\n", bd_addr_to_str(speaker));
hfp_ag_connect(speaker);
return 0;
}
int btstack_main(int argc, const char * argv[]){
// init L2CAP
l2cap_init();
rfcomm_init();
// hfp_hf_init(rfcomm_channel_nr, HFP_DEFAULT_HF_SUPPORTED_FEATURES, codecs, sizeof(codecs), indicators, sizeof(indicators)/sizeof(uint16_t), 1);
hfp_hf_init(rfcomm_channel_nr);
hfp_hf_init_supported_features(438 | (1<<HFP_HFSF_ESCO_S4) | (1<<HFP_HFSF_EC_NR_FUNCTION));
hfp_hf_init_hf_indicators(sizeof(indicators)/sizeof(uint16_t), indicators);
hfp_hf_init_codecs(sizeof(codecs), codecs);
hfp_hf_register_packet_handler(packet_handler);
sdp_init();
// init SDP, create record for SPP and register with SDP
memset((uint8_t *)hfp_service_buffer, 0, sizeof(hfp_service_buffer));
hfp_hf_create_sdp_record((uint8_t *)hfp_service_buffer, rfcomm_channel_nr, hfp_hf_service_name, 0);
sdp_register_service_internal(NULL, (uint8_t *)hfp_service_buffer);
// pre-select pts
memcpy(device_addr, pts_addr, 6);
// turn on!
hci_power_control(HCI_POWER_ON);
btstack_stdin_setup(stdin_process);
// printf("Establishing HFP connection to %s...\n", bd_addr_to_str(phone_addr));
// hfp_hf_connect(phone_addr);
return 0;
}
int btstack_main(void)
{
// register for HCI events
hci_event_callback_registration.callback = &packet_handler;
hci_add_event_handler(&hci_event_callback_registration);
l2cap_init();
rfcomm_init();
rfcomm_register_service(packet_handler, RFCOMM_SERVER_CHANNEL, 0xffff);
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
spp_create_sdp_record(spp_service_buffer, 0x10001, RFCOMM_SERVER_CHANNEL, "SPP Counter");
sdp_register_service(spp_service_buffer);
printf("SDP service record size: %u\n", de_get_len(spp_service_buffer));
gap_set_local_name("SPP and LE Counter 00:00:00:00:00:00");
gap_ssp_set_io_capability(SSP_IO_CAPABILITY_DISPLAY_YES_NO);
gap_discoverable_control(1);
// setup le device db
le_device_db_init();
// setup SM: Display only
sm_init();
// setup ATT server
att_server_init(profile_data, att_read_callback, att_write_callback);
att_server_register_packet_handler(packet_handler);
// set one-shot timer
heartbeat.process = &heartbeat_handler;
btstack_run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
btstack_run_loop_add_timer(&heartbeat);
// setup advertisements
uint16_t adv_int_min = 0x0030;
uint16_t adv_int_max = 0x0030;
uint8_t adv_type = 0;
bd_addr_t null_addr;
memset(null_addr, 0, 6);
gap_advertisements_set_params(adv_int_min, adv_int_max, adv_type, 0, null_addr, 0x07, 0x00);
gap_advertisements_set_data(adv_data_len, (uint8_t*) adv_data);
gap_advertisements_enable(1);
// beat once
beat();
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
int sdpreg_init(void)
{
if (srvHandle >= 0)
return 0;
// initialize the SDP internal data structures
if (sdp_init(SDP_SVC_PROVIDER) != 0)
return -1;
srvHandle = sdp_connect_local();
if (srvHandle < 0)
return srvHandle;
return 0;
}
int btstack_main(int argc, const char * argv[]){
printf("Starting up..\n");
hci_set_class_of_device(0x200404);
hci_disable_l2cap_timeout_check();
hci_ssp_set_io_capability(IO_CAPABILITY_NO_INPUT_NO_OUTPUT);
gap_io_capabilities = "IO_CAPABILITY_NO_INPUT_NO_OUTPUT";
hci_ssp_set_authentication_requirement(0);
hci_ssp_set_auto_accept(0);
// gap_set_bondable_mode(0);
l2cap_init();
l2cap_register_packet_handler(&packet_handler2);
l2cap_register_fixed_channel(&packet_handler, L2CAP_CID_CONNECTIONLESS_CHANNEL);
rfcomm_init();
rfcomm_register_packet_handler(packet_handler2);
rfcomm_register_service_internal(NULL, RFCOMM_SERVER_CHANNEL, 150); // reserved channel, mtu=100
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
sdp_create_spp_service((uint8_t*) spp_service_buffer, RFCOMM_SERVER_CHANNEL, "SPP Counter");
de_dump_data_element((uint8_t*) spp_service_buffer);
printf("SDP service record size: %u\n\r", de_get_len((uint8_t*)spp_service_buffer));
sdp_register_service_internal(NULL, (uint8_t*)spp_service_buffer);
memset(dummy_service_buffer, 0, sizeof(dummy_service_buffer));
sdp_create_dummy_service((uint8_t*)dummy_service_buffer, "UUID128 Test");
de_dump_data_element((uint8_t*)dummy_service_buffer);
printf("Dummy service record size: %u\n\r", de_get_len((uint8_t*)dummy_service_buffer));
sdp_register_service_internal(NULL, (uint8_t*)dummy_service_buffer);
sdp_query_rfcomm_register_callback(handle_query_rfcomm_event, NULL);
hci_discoverable_control(0);
hci_connectable_control(0);
// turn on!
hci_power_control(HCI_POWER_ON);
btstack_stdin_setup(stdin_process);
// set one-shot timer
// timer_source_t heartbeat;
// heartbeat.process = &heartbeat_handler;
// run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
// run_loop_add_timer(&heartbeat);
return 0;
}
int btstack_main(void)
{
hci_discoverable_control(1);
l2cap_init();
l2cap_register_packet_handler(packet_handler);
rfcomm_init();
rfcomm_register_packet_handler(packet_handler);
rfcomm_register_service_internal(NULL, RFCOMM_SERVER_CHANNEL, 0xffff);
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
/* LISTING_PAUSE */
#ifdef EMBEDDED
/* LISTING_RESUME */
service_record_item_t * service_record_item = (service_record_item_t *) spp_service_buffer;
sdp_create_spp_service( (uint8_t*) &service_record_item->service_record, RFCOMM_SERVER_CHANNEL, "SPP Counter");
printf("SDP service buffer size: %u\n", (uint16_t) (sizeof(service_record_item_t) + de_get_len((uint8_t*) &service_record_item->service_record)));
sdp_register_service_internal(NULL, service_record_item);
/* LISTING_PAUSE */
#else
sdp_create_spp_service( spp_service_buffer, RFCOMM_SERVER_CHANNEL, "SPP Counter");
printf("SDP service record size: %u\n", de_get_len(spp_service_buffer));
sdp_register_service_internal(NULL, spp_service_buffer);
#endif
/* LISTING_RESUME */
hci_ssp_set_io_capability(SSP_IO_CAPABILITY_DISPLAY_YES_NO);
// setup le device db
le_device_db_init();
// setup SM: Display only
sm_init();
// setup ATT server
att_server_init(profile_data, att_read_callback, att_write_callback);
att_dump_attributes();
// set one-shot timer
heartbeat.process = &heartbeat_handler;
run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
run_loop_add_timer(&heartbeat);
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
/*****************************************************************************
**
** Function btu_init_core
**
** Description Initialize control block memory for each core component.
**
**
** Returns void
**
******************************************************************************/
void btu_init_core(void)
{
/* Initialize the mandatory core stack components */
btm_init();
l2c_init();
sdp_init();
#if BLE_INCLUDED == TRUE
gatt_init();
#if (defined(SMP_INCLUDED) && SMP_INCLUDED == TRUE)
SMP_Init();
#endif
btm_ble_init();
#endif
}
static void init_everything() {
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
srandom(ts.tv_sec ^ ts.tv_nsec);
SSL_library_init();
SSL_load_error_strings();
#if !GLIB_CHECK_VERSION(2,32,0)
g_thread_init(NULL);
#endif
if (!_log_stderr)
openlog("rtpengine", LOG_PID | LOG_NDELAY, _log_facility);
signals();
resources();
sdp_init();
dtls_init();
}
int btstack_main(int argc, const char * argv[]){
// init SDP, create record for SPP and register with SDP
memset((uint8_t *)hsp_service_buffer, 0, sizeof(hsp_service_buffer));
hsp_ag_create_service((uint8_t *)hsp_service_buffer, rfcomm_channel_nr, hsp_ag_service_name);
hsp_ag_init(rfcomm_channel_nr);
hsp_ag_register_packet_handler(packet_handler);
sdp_init();
sdp_register_service_internal(NULL, (uint8_t *)hsp_service_buffer);
// turn on!
hci_power_control(HCI_POWER_ON);
btstack_stdin_setup(stdin_process);
return 0;
}
int btstack_main(int argc, const char * argv[]){
memset((uint8_t *)hsp_service_buffer, 0, sizeof(hsp_service_buffer));
hsp_hs_create_sdp_record((uint8_t *)hsp_service_buffer, rfcomm_channel_nr, hsp_hs_service_name, 0);
hsp_hs_init(rfcomm_channel_nr);
hsp_hs_register_packet_handler(packet_handler);
sdp_init();
sdp_register_service_internal(NULL, (uint8_t *)hsp_service_buffer);
hci_discoverable_control(1);
hci_set_class_of_device(0x200418);
btstack_stdin_setup(stdin_process);
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
int btstack_main(int argc, const char * argv[]){
UNUSED(argc);
(void)argv;
/* Register for HCI events */
hci_event_callback_registration.callback = &packet_handler;
hci_add_event_handler(&hci_event_callback_registration);
l2cap_init();
// Initialize AVDTP Sink
avdtp_sink_init(&a2dp_sink_context);
avdtp_sink_register_packet_handler(&packet_handler);
avdtp_stream_endpoint_t * local_stream_endpoint = avdtp_sink_create_stream_endpoint(AVDTP_SINK, AVDTP_AUDIO);
if (!local_stream_endpoint) {
printf("AVDTP Sink: not enough memory to create local_stream_endpoint\n");
return 1;
}
local_seid = avdtp_local_seid(local_stream_endpoint);
avdtp_sink_register_media_transport_category(local_seid);
avdtp_sink_register_media_codec_category(local_seid, AVDTP_AUDIO, AVDTP_CODEC_SBC, media_sbc_codec_capabilities, sizeof(media_sbc_codec_capabilities));
avdtp_sink_register_media_handler(&handle_l2cap_media_data_packet);
// Initialize SDP
sdp_init();
memset(sdp_avdtp_sink_service_buffer, 0, sizeof(sdp_avdtp_sink_service_buffer));
a2dp_sink_create_sdp_record(sdp_avdtp_sink_service_buffer, 0x10001, 1, NULL, NULL);
sdp_register_service(sdp_avdtp_sink_service_buffer);
// printf("BTstack AVDTP Sink, supported features 0x%04x\n", );
gap_set_local_name("BTstack AVDTP Sink PTS 00:00:00:00:00:00");
gap_discoverable_control(1);
gap_set_class_of_device(0x200408);
#ifdef HAVE_BTSTACK_STDIN
// parse human readable Bluetooth address
sscanf_bd_addr(device_addr_string, device_addr);
btstack_stdin_setup(stdin_process);
#endif
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
int btstack_main(int argc, const char * argv[]){
hci_discoverable_control(1);
l2cap_init();
l2cap_register_packet_handler(packet_handler);
rfcomm_init();
rfcomm_register_packet_handler(packet_handler);
rfcomm_register_service_internal(NULL, RFCOMM_SERVER_CHANNEL, 0xffff); // reserved channel, mtu limited by l2cap
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
#ifdef EMBEDDED
service_record_item_t * service_record_item = (service_record_item_t *) spp_service_buffer;
sdp_create_spp_service( (uint8_t*) &service_record_item->service_record, RFCOMM_SERVER_CHANNEL, "SPP Counter");
printf("SDP service buffer size: %u\n", (uint16_t) (sizeof(service_record_item_t) + de_get_len((uint8_t*) &service_record_item->service_record)));
sdp_register_service_internal(NULL, service_record_item);
#else
sdp_create_spp_service( spp_service_buffer, RFCOMM_SERVER_CHANNEL, "SPP Counter");
printf("SDP service record size: %u\n", de_get_len(spp_service_buffer));
sdp_register_service_internal(NULL, spp_service_buffer);
#endif
hci_ssp_set_io_capability(SSP_IO_CAPABILITY_DISPLAY_YES_NO);
// set one-shot timer
timer_source_t heartbeat;
heartbeat.process = &heartbeat_handler;
run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
run_loop_add_timer(&heartbeat);
// turn on!
hci_power_control(HCI_POWER_ON);
// go!
run_loop_execute();
// happy compiler!
return 0;
}
static int spl_sdp_load_image(struct spl_image_info *spl_image,
struct spl_boot_device *bootdev)
{
int ret;
const int controller_index = 0;
g_dnl_clear_detach();
g_dnl_register("usb_dnl_sdp");
ret = sdp_init(controller_index);
if (ret) {
error("SDP init failed: %d", ret);
return -ENODEV;
}
/* This command typically does not return but jumps to an image */
sdp_handle(controller_index);
error("SDP ended");
return -EINVAL;
}
/* LISTING_START(explicitFlowControl): Providing one initial credit during RFCOMM service initialization */
static void spp_service_setup(void){
// register for HCI events
hci_event_callback_registration.callback = &packet_handler;
hci_add_event_handler(&hci_event_callback_registration);
// init L2CAP
l2cap_init();
// init RFCOMM
rfcomm_init();
// reserved channel, mtu limited by l2cap, 1 credit
rfcomm_register_service_with_initial_credits(&packet_handler, rfcomm_channel_nr, 0xffff, 1);
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
spp_create_sdp_record(spp_service_buffer, 0x10001, 1, "SPP Counter");
sdp_register_service(spp_service_buffer);
printf("SDP service buffer size: %u\n\r", (uint16_t) de_get_len(spp_service_buffer));
}
