int btstack_main(int argc, const char * argv[]){ int arg = 1; cmdline_addr_found = 0; while (arg < argc) { if(!strcmp(argv[arg], "-a") || !strcmp(argv[arg], "--address")){ arg++; cmdline_addr_found = sscan_bd_addr((uint8_t *)argv[arg], cmdline_addr); arg++; continue; } usage(argv[0]); return 0; } l2cap_init(); l2cap_register_packet_handler(&handle_hci_event); gatt_client_init(); gc_id = gatt_client_register_packet_handler(&handle_gatt_client_event); sm_init(); sm_set_io_capabilities(IO_CAPABILITY_NO_INPUT_NO_OUTPUT); // turn on! hci_power_control(HCI_POWER_ON); // go! run_loop_execute(); // happy compiler! return 0; }
void hfp_ag_init(uint16_t rfcomm_channel_nr, uint32_t supported_features, uint8_t * codecs, int codecs_nr, hfp_ag_indicator_t * ag_indicators, int ag_indicators_nr, hfp_generic_status_indicator_t * hf_indicators, int hf_indicators_nr, const char *call_hold_services[], int call_hold_services_nr){ if (codecs_nr > HFP_MAX_NUM_CODECS){ log_error("hfp_init: codecs_nr (%d) > HFP_MAX_NUM_CODECS (%d)", codecs_nr, HFP_MAX_NUM_CODECS); return; } l2cap_init(); l2cap_register_packet_handler(packet_handler); rfcomm_register_packet_handler(packet_handler); hfp_init(rfcomm_channel_nr); hfp_supported_features = supported_features; hfp_codecs_nr = codecs_nr; int i; for (i=0; i<codecs_nr; i++){ hfp_codecs[i] = codecs[i]; } hfp_ag_indicators_nr = ag_indicators_nr; memcpy(hfp_ag_indicators, ag_indicators, ag_indicators_nr * sizeof(hfp_ag_indicator_t)); set_hfp_generic_status_indicators(hf_indicators, hf_indicators_nr); hfp_ag_call_hold_services_nr = call_hold_services_nr; memcpy(hfp_ag_call_hold_services, call_hold_services, call_hold_services_nr * sizeof(char *)); }
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[]){ /* 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; }
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); }
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); // set up l2cap_le l2cap_init(); l2cap_register_fixed_channel(att_packet_handler, L2CAP_CID_ATTRIBUTE_PROTOCOL); l2cap_register_fixed_channel(sm_packet_handler, L2CAP_CID_SECURITY_MANAGER_PROTOCOL); l2cap_register_packet_handler(packet_handler); // set up ATT att_set_db(profile_data); att_set_write_callback(att_write_callback); att_dump_attributes(); att_connection.mtu = 27; }
void bluetooth_spp_initialize(void){ // l2cap_require_security_level_2_for_outgoing_sdp(); sdp_query_rfcomm_register_callback(handle_query_rfcomm_event, NULL); hci_discoverable_control(1); // Secure Simple Pairing configuration -> just works // hci_ssp_set_enable(1); // hci_ssp_set_io_capability(SSP_IO_CAPABILITY_NO_INPUT_NO_OUTPUT); // hci_ssp_set_auto_accept(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, "Serial Port Profile"); // 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); }
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[]){ // 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; }
/* 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 */ }
// main int main(void) { /// GET STARTED with BTstack /// btstack_memory_init(); run_loop_init(RUN_LOOP_POSIX); // 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 = (remote_device_db_t *) &remote_device_db_memory; hci_init(transport, config, control, remote_db); // set up l2cap_le l2cap_init(); l2cap_register_fixed_channel(att_packet_handler, L2CAP_CID_ATTRIBUTE_PROTOCOL); l2cap_register_packet_handler(packet_handler); // set up ATT att_set_db(profile_data); att_set_write_callback(att_write_callback); att_dump_attributes(); att_connection.mtu = 27; printf("Run...\n\r"); // turn on! hci_power_control(HCI_POWER_ON); // go! run_loop_execute(); // happy compiler! return 0; }
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/gatt_browser.pklg", HCI_DUMP_PACKETLOGGER); // init HCI remote_device_db_t * remote_db = (remote_device_db_t *) &remote_device_db_memory; bt_control_t * control = NULL; #ifndef HAVE_UART_CC2564 hci_transport_t * transport = hci_transport_usb_instance(); #else hci_transport_t * transport = hci_transport_h4_instance(); control = bt_control_cc256x_instance(); // config.device_name = "/dev/tty.usbserial-A600eIDu"; // 5438 config.device_name = "/dev/tty.usbserial-A800cGd0"; // 5529 config.baudrate_init = 115200; config.baudrate_main = 0; config.flowcontrol = 1; #endif hci_init(transport, &config, control, remote_db); l2cap_init(); l2cap_register_packet_handler(&handle_hci_event); gatt_client_init(); gatt_client_register_packet_handler(&handle_gatt_client_event); sm_init(); sm_set_io_capabilities(IO_CAPABILITY_NO_INPUT_NO_OUTPUT); }
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; }
static void sdp_client_init(void){ // init L2CAP l2cap_init(); l2cap_register_packet_handler(packet_handler); sdp_parser_init(); sdp_parser_register_callback(handle_sdp_client_query_result); }
void hsp_hs_init(uint8_t rfcomm_channel_nr){ // init L2CAP l2cap_register_packet_handler(packet_handler); 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; }
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; }
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 main(void){ // stop watchdog timer WDTCTL = WDTPW + WDTHOLD; //Initialize clock and peripherals halBoardInit(); halBoardStartXT1(); halBoardSetSystemClock(SYSCLK_16MHZ); // Debug UART halUsbInit(); // show off doLCD(); // init LEDs LED_PORT_OUT |= LED_1 | LED_2; LED_PORT_DIR |= LED_1 | LED_2; /// GET STARTED /// 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); // ready - enable irq used in h4 task __enable_interrupt(); // turn on! hci_power_control(HCI_POWER_ON); // go! run_loop_execute(); return 0; }
int btstack_main(int argc, const char * argv[]){ hci_set_class_of_device(0x200404); hci_discoverable_control(1); l2cap_init(); l2cap_register_packet_handler(&packet_handler2); l2cap_register_service_internal(NULL, packet_handler, PSM_SDP, 100, LEVEL_0); // turn on! hci_power_control(HCI_POWER_ON); btstack_stdin_setup(stdin_process); 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[]){ printf("Client HCI init done\r\n"); // init L2CAP l2cap_init(); l2cap_register_packet_handler(packet_handler); sdp_parser_init(); sdp_parser_register_callback(handle_sdp_client_query_result); // turn on! hci_power_control(HCI_POWER_ON); // go! run_loop_execute(); return 0; }
static void btstack_setup(){ /// 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); }
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 void btstack_setup(){ /// GET STARTED /// btstack_memory_init(); run_loop_init(RUN_LOOP_POSIX); hci_dump_open("/tmp/hci_dump_sdp_rfcomm_query.pklg", HCI_DUMP_PACKETLOGGER); 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); printf("Client HCI init done\r\n"); // init L2CAP l2cap_init(); l2cap_register_packet_handler(packet_handler); // turn on! hci_power_control(HCI_POWER_ON); }
static void btstack_setup(){ printf("Starting up..\n"); /// GET STARTED /// btstack_memory_init(); run_loop_init(RUN_LOOP_POSIX); hci_dump_open("/tmp/hci_dump.pklg", HCI_DUMP_PACKETLOGGER); 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_set_class_of_device(0x200404); hci_discoverable_control(1); l2cap_init(); l2cap_register_packet_handler(&packet_handler2); l2cap_register_service_internal(NULL, packet_handler, PSM_SDP, 100, LEVEL_0); // turn on! hci_power_control(HCI_POWER_ON); }
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 ) { // 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 ble_client_init(){ gatt_client_init(); l2cap_register_packet_handler(ble_packet_handler); }
// 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; }