/* 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 */
}
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;
}
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;
}
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");
}
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[]){
// 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;
}
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){
// 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(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;
}
void hsp_hs_init(uint8_t rfcomm_channel_nr){
// register for HCI events
hci_event_callback_registration.callback = &packet_handler;
hci_add_event_handler(&hci_event_callback_registration);
rfcomm_init();
rfcomm_register_service(packet_handler, rfcomm_channel_nr, 0xffff); // reserved channel, mtu limited by l2cap
hsp_hs_reset_state();
}
void hsp_hs_init(uint8_t rfcomm_channel_nr){
// init L2CAP
l2cap_init();
l2cap_register_packet_handler(packet_handler);
rfcomm_init();
rfcomm_register_packet_handler(packet_handler);
rfcomm_register_service_internal(NULL, rfcomm_channel_nr, 0xffff); // reserved channel, mtu limited by l2cap
sdp_query_rfcomm_register_callback(handle_query_rfcomm_event, NULL);
hsp_hs_reset_state();
}
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;
}
void bluetooth_spp_initialize(void){
remote_spp_channel = 0;
local_spp_channel = 0;
sdp_query_rfcomm_register_callback(sdp_query_callback, NULL);
l2cap_init();
l2cap_register_packet_handler(packet_handler);
rfcomm_init();
rfcomm_register_packet_handler(packet_handler);
// sdp_init();
}
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;
}
int btstack_main(int argc, const char * argv[]){
printf("Client HCI init done\r\n");
// init L2CAP
l2cap_init();
l2cap_register_packet_handler(packet_handler);
rfcomm_init();
rfcomm_register_packet_handler(packet_handler);
sdp_query_rfcomm_register_callback(handle_query_rfcomm_event, NULL);
// 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;
}
int btstack_main(int argc, const char * argv[]){
l2cap_init();
rfcomm_init();
hsp_ag_init(rfcomm_channel_nr);
hsp_ag_register_packet_handler(packet_handler);
// init SDP, create record for SPP and register with SDP
sdp_init();
memset((uint8_t *)hsp_service_buffer, 0, sizeof(hsp_service_buffer));
hsp_ag_create_sdp_record((uint8_t *)hsp_service_buffer, 0x10003, rfcomm_channel_nr, hsp_ag_service_name);
sdp_register_service((uint8_t *)hsp_service_buffer);
// turn on!
hci_power_control(HCI_POWER_ON);
btstack_stdin_setup(stdin_process);
return 0;
}
/* 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));
}
int btstack_main(int argc, const char * argv[]){
l2cap_init();
rfcomm_init();
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_sdp_record((uint8_t *)hsp_service_buffer, 0x10004, rfcomm_channel_nr, hsp_hs_service_name, 0);
sdp_register_service((uint8_t *)hsp_service_buffer);
gap_discoverable_control(1);
gap_set_class_of_device(0x200418);
gap_set_local_name("BTstack HSP HS PTS");
btstack_stdin_setup(stdin_process);
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
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);
// init L2CAP
l2cap_init();
// init RFCOMM
rfcomm_init();
rfcomm_register_service(packet_handler, 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));
spp_create_sdp_record( (uint8_t*) spp_service_buffer, 0x10001, 1, "SPP Counter");
printf("SDP service buffer size: %u\n\r", (uint16_t) de_get_len((uint8_t*) spp_service_buffer));
sdp_register_service(spp_service_buffer);
// set one-shot timer
btstack_timer_source_t heartbeat;
heartbeat.process = &heartbeat_handler;
btstack_run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
btstack_run_loop_add_timer(&heartbeat);
// set local name
gap_set_local_name("BlueMSP-Demo");
// make discoverable
gap_discoverable_control(1);
printf("Run...\n\r");
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
int main (int argc, char * const * argv){
static int tcp_flag = 0;
while (1) {
static struct option long_options[] = {
{ "tcp", no_argument, &tcp_flag, 1 },
{ "help", no_argument, 0, 0 },
{ 0,0,0,0 } // This is a filler for -1
};
int c;
int option_index = -1;
c = getopt_long(argc, argv, "h", long_options, &option_index);
if (c == -1) break; // no more option
// treat long parameter first
if (option_index == -1) {
switch (c) {
case '?':
case 'h':
usage(argv[0]);
return 0;
break;
}
} else {
switch (option_index) {
case 1:
usage(argv[0]);
return 0;
break;
}
}
}
// make stdout unbuffered
setbuf(stdout, NULL);
log_error("BTdaemon started\n");
// handle CTRL-c
signal(SIGINT, daemon_sigint_handler);
// handle SIGTERM - suggested for launchd
signal(SIGTERM, daemon_sigint_handler);
// handle SIGPIPE
struct sigaction act;
act.sa_handler = SIG_IGN;
sigemptyset (&act.sa_mask);
act.sa_flags = 0;
sigaction (SIGPIPE, &act, NULL);
bt_control_t * control = NULL;
#ifdef HAVE_TRANSPORT_H4
config.device_name = UART_DEVICE;
config.baudrate_init = UART_SPEED;
config.baudrate_main = 0;
config.flowcontrol = 1;
#if defined(USE_BLUETOOL) && defined(USE_POWERMANAGEMENT)
if (bt_control_iphone_power_management_supported()){
// use default (max) UART baudrate over netraph interface
config.baudrate_init = 0;
transport = hci_transport_h4_iphone_instance();
} else {
transport = hci_transport_h4_instance();
}
#else
transport = hci_transport_h4_instance();
#endif
#endif
#ifdef HAVE_TRANSPORT_USB
transport = hci_transport_usb_instance();
#endif
#ifdef USE_BLUETOOL
control = &bt_control_iphone;
#endif
#if defined(USE_BLUETOOL) && defined(USE_POWERMANAGEMENT)
if (bt_control_iphone_power_management_supported()){
hci_transport_h4_iphone_set_enforce_wake_device("/dev/btwake");
}
#endif
#ifdef USE_SPRINGBOARD
bluetooth_status_handler = platform_iphone_status_handler;
platform_iphone_register_window_manager_restart(update_ui_status);
platform_iphone_register_preferences_changed(preferences_changed_callback);
#endif
#ifdef REMOTE_DEVICE_DB
remote_device_db = &REMOTE_DEVICE_DB;
#endif
run_loop_init(RUN_LOOP_POSIX);
// init power management notifications
if (control && control->register_for_power_notifications){
control->register_for_power_notifications(power_notification_callback);
}
// logging
loggingEnabled = 0;
int newLoggingEnabled = 1;
#ifdef USE_BLUETOOL
// iPhone has toggle in Preferences.app
newLoggingEnabled = platform_iphone_logging_enabled();
#endif
daemon_set_logging_enabled(newLoggingEnabled);
// init HCI
hci_init(transport, &config, control, remote_device_db);
#ifdef USE_BLUETOOL
// iPhone doesn't use SSP yet as there's no UI for it yet and auto accept is not an option
hci_ssp_set_enable(0);
#endif
// init L2CAP
l2cap_init();
l2cap_register_packet_handler(daemon_packet_handler);
timeout.process = daemon_no_connections_timeout;
#ifdef HAVE_RFCOMM
log_info("config.h: HAVE_RFCOMM\n");
rfcomm_init();
rfcomm_register_packet_handler(daemon_packet_handler);
#endif
#ifdef HAVE_SDP
sdp_init();
sdp_register_packet_handler(daemon_packet_handler);
#endif
#ifdef USE_LAUNCHD
socket_connection_create_launchd();
#else
// create server
if (tcp_flag) {
socket_connection_create_tcp(BTSTACK_PORT);
} else {
socket_connection_create_unix(BTSTACK_UNIX);
}
#endif
socket_connection_register_packet_callback(daemon_client_handler);
#ifdef USE_BLUETOOL
// notify daemons
notify_post("ch.ringwald.btstack.started");
// spawn thread to have BTstack run loop on new thread, while main thread is used to keep CFRunLoop
pthread_t run_loop;
pthread_create(&run_loop, NULL, &run_loop_thread, NULL);
// needed to receive notifications
CFRunLoopRun();
#endif
// go!
run_loop_execute();
return 0;
}
// main
int main(void)
{
// stop watchdog timer
WDTCTL = WDTPW + WDTHOLD;
//Initialize clock and peripherals
halBoardInit();
halBoardStartXT1();
halBoardSetSystemClock(SYSCLK_16MHZ);
// init debug UART
halUsbInit();
// init LEDs
LED_PORT_OUT |= LED_1 | LED_2;
LED_PORT_DIR |= LED_1 | LED_2;
/// GET STARTED with BTstack ///
btstack_memory_init();
run_loop_init(RUN_LOOP_EMBEDDED);
// init HCI
hci_transport_t * transport = hci_transport_h4_dma_instance();
bt_control_t * control = bt_control_cc256x_instance();
hci_uart_config_t * config = hci_uart_config_cc256x_instance();
remote_device_db_t * remote_db = (remote_device_db_t *) &remote_device_db_memory;
hci_init(transport, config, control, remote_db);
// use eHCILL
bt_control_cc256x_enable_ehcill(1);
// 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, 100, 1); // reserved channel, mtu=100, 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
timer_source_t heartbeat;
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");
// ready - enable irq used in h4 task
__enable_interrupt();
// turn on!
hci_power_control(HCI_POWER_ON);
// go!
run_loop_execute();
// happy compiler!
return 0;
}
/*-----------------------------------------------------------------------------------*/
int
main(int argc, char **argv)
{
struct phybusif_cb *cb;
struct timeval tcptv, bttv, now;
struct timezone tz;
u8_t btiptmr = 0;
#ifdef PERF
perf_init("/tmp/minimal.perf");
#endif /* PERF */
#ifdef STATS
stats_init();
#endif /* STATS */
mem_init();
memp_init();
pbuf_init();
netif_init();
ip_init();
//udp_init();
tcp_init();
printf("TCP/IP initialized.\n");
lwbt_memp_init();
phybusif_init();
if(hci_init() != ERR_OK) {
printf("HCI initialization failed!");
exit(-1);
}
l2cap_init();
sdp_init();
rfcomm_init();
ppp_init();
printf("Bluetooth initialized.\n");
//echo_init();
httpd_init();
printf("Applications started.\n");
cb = malloc(sizeof(struct phybusif_cb));
phybusif_reset(cb);
gettimeofday(&bttv, &tz); /* Initialize Bluetooth timer (1s) */
gettimeofday(&tcptv, &tz); /* Initialize TCP timer (TCP_TMR_INTERVAL) */
/* Host controller initialization for DTs according to LAN access point (LAP) and dial up networking (DUN) profile */
bt_ip_start(NULL);
while(1) {
phybusif_input(cb); /* Check for input */
gettimeofday(&now, &tz); /* Get current time */
/* Check if TCP timer should be called */
if((now.tv_sec - tcptv.tv_sec) * 1000000 + (now.tv_usec - tcptv.tv_usec) >= TCP_TMR_INTERVAL * 1000) {
gettimeofday(&tcptv, &tz); /* Reset TCP timer */
tcp_tmr();
}
/* Check if Bluetooth and NAT timers should be called */
if((now.tv_sec - bttv.tv_sec) * 1000000 + (now.tv_usec - bttv.tv_usec) >= 1000000) {
gettimeofday(&bttv, &tz); /* Restart Bluetooth timer */
l2cap_tmr();
rfcomm_tmr();
ppp_tmr();
nat_tmr();
if(++btiptmr == 240) { /* Akes server special */
bt_ip_tmr();
btiptmr = 0;
}
}
}
return 0;
}
// main
int main ( void )
{
// Initialize the processor and peripherals.
// Init Clock
// CPU 32MHz
// Peripheral 8MHz
CLKDIV = 0x0000;
unsigned int pll_startup_counter = 600;
CLKDIVbits.PLLEN = 1;
while(pll_startup_counter--);
// Configure U2RX - put on pin 17 (RP8)
RPINR19bits.U2RXR = 8;
// Configure U2TX - put on pin 16 (RP7)
RPOR3bits.RP7R = 5;
// Analog IN Disable
AD1PCFG = 0xffff;
EnablePullUpCN12;
// Port output setup
mPORTBOutputConfig(0x8000);
// Init UART
UART2Init();
// Init USB
if ( USBHostInit(0) != TRUE )
{
UART2PrintString( "ERR USBHostInit\r\n" );
while (1);
}
/// GET STARTED with BTstack ///
btstack_memory_init();
run_loop_init(RUN_LOOP_EMBEDDED);
// init HCI
hci_transport_t * transport = hci_transport_usb_instance();
bt_control_t * control = NULL;
hci_uart_config_t * config = NULL;
remote_device_db_t * remote_db = NULL;//(remote_device_db_t *) &remote_device_db_memory;
hci_init(transport, config, control, remote_db);
// init L2CAP
l2cap_init();
l2cap_register_packet_handler(bt_packet_handler);
// init RFCOMM
rfcomm_init();
rfcomm_register_packet_handler(bt_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");
// 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);
// usbhost
data_source_t usbhost;
usbhost.process = &usbhost_process;
run_loop_add_data_source(&usbhost);
data_source_t swtask;
swtask.process = &sw_process;
run_loop_add_data_source(&swtask);
// go!
run_loop_execute();
return 0;
} // main
/*-----------------------------------------------------------------------------------*/
void
maintask(void)
{
struct phybusif_cb *cb;
CLKBLK ks_clk *tmr;
u8_t bt_timer = 0;
u16_t http_timer = 0;
u16_t dma0bsz = TCR0+1; /* DMA 0 Buf size */
u8_t bt_ip_timer = 0;
mem_init();
memp_init();
pbuf_init();
netif_init();
ip_init();
tcp_init();
sio_print("TCP/IP initialized.\n");
lwbt_memp_init();
phybusif_init();
if(hci_init() != ERR_OK) {
sio_print("HCI initialization failed!");
}
l2cap_init();
sdp_init();
rfcomm_init();
ppp_init();
sio_print("Bluetooth initialized.\n");
httpd_init();
sio_print("Applications started.\n");
cb = mem_malloc(sizeof(struct phybusif_cb));
cb->dmabuf = get_dm0ichars();
phybusif_reset(cb);
tmr = KS_alloc_timer();
if(tmr == 0) {
sio_print("tmr==0!\n");
}
KS_start_timer(tmr, (TICKS)0, (TICKS)100/CLKTICK, TIMERSEM); /* TCP timer ticks every 100ms */
/* Reset Bluetooth module */
PD7.0 = 1; /* Enable output */
sio_print("Reseting BT module\n");
P7.0 = 1; /* Stop reset */
KS_delay(SELFTASK,(TICKS)4000/CLKTICK); /* Wait for bluetooth module to init */
/* Control application initialisation */
bt_ip_start();
while(1) {
dma_input(cb, dma0bsz); /* Check for input */
/* Handle timers */
if(KS_inqsema(TIMERSEM) == SEMA_DONE) {
KS_wait(TIMERSEM);
tcp_tmr();
++bt_timer;
if(bt_timer == 10) {
l2cap_tmr();
rfcomm_tmr();
ppp_tmr();
bt_timer = 0;
++bt_ip_timer;
if(bt_ip_timer == 240) {
bt_ip_tmr();
bt_ip_timer = 0;
}
}
}
}
}
