Ignore:
Timestamp:
Apr 5, 2019, 9:26:53 PM (5 years ago)
Author:
coas-nagasima
Message:

mbed関連を更新
シリアルドライバをmbedのHALを使うよう変更
ファイルディスクリプタの処理を更新

File:
1 moved

Legend:

Unmodified
Added
Removed
  • asp3_tinet_ecnl_arm/trunk/asp3_dcre/tinet/netdev/if_btusb/bt_main.c

    r373 r374  
    5858#include "sdp.h"
    5959#include "pan.h"
    60 #include "panu_main.h"
     60#include "bt_main.h"
     61#include "usb_hbth.h"
    6162
    6263//#define PACKET_DUMP
     
    6667
    6768#define RFCOMM_SERVER_CHANNEL 1
    68 /*static*/ uint16_t  rfcomm_channel_id = FAILED_RFCOMM_ID_NOT_SET;
     69static uint16_t  rfcomm_channel_id = FAILED_RFCOMM_ID_NOT_SET;
    6970
    7071static int record_id = -1;
     
    9091
    9192volatile int bt_bnep_mode = 0;
    92 bool_t bt_enabled = false;
     93
     94enum bt_state_t {
     95        BT_STATE_DORMANT,
     96        BT_STATE_POWER_ON,
     97        BT_STATE_BNEP_QUERY,
     98        BT_STATE_BNEP_WAIT,
     99        BT_STATE_BNEP_QUERY_WAIT,
     100        BT_STATE_CONNECTING,
     101        BT_STATE_CONNECTED,
     102};
     103
     104enum bt_state_t bt_state = BT_STATE_DORMANT;
     105int bt_timer;
    93106
    94107// outgoing network packet
     
    108121                break;
    109122        case DE_SIZE_VAR_16:
    110                 len = READ_NET_16(element, 1);
     123                len = big_endian_read_16(element, 1);
    111124                break;
    112125        default:
     
    129142
    130143        // accept first entry or if we foudn a NAP and only have a PANU yet
    131         if ((bnep_remote_uuid == 0) || (sdp_bnep_remote_uuid == BNEP_UUID_NAP && bnep_remote_uuid == BNEP_UUID_PANU)) {
     144        if ((bnep_remote_uuid == 0) || (sdp_bnep_remote_uuid == BLUETOOTH_SERVICE_CLASS_NAP && bnep_remote_uuid == BLUETOOTH_SERVICE_CLASS_PANU)) {
    132145                bnep_l2cap_psm = sdp_bnep_l2cap_psm;
    133146                bnep_remote_uuid = sdp_bnep_remote_uuid;
     
    146159
    147160        switch (event->type) {
    148         case SDP_QUERY_ATTRIBUTE_VALUE:
     161        case SDP_EVENT_QUERY_ATTRIBUTE_VALUE:
    149162                value_event = (sdp_query_attribute_value_event_t*)event;
    150163
     
    165178
    166179                                switch (value_event->attribute_id) {
    167                                 case SDP_ServiceClassIDList:
     180                                case BLUETOOTH_ATTRIBUTE_SERVICE_CLASS_ID_LIST:
    168181                                        if (de_get_element_type(attribute_value) != DE_DES) break;
    169182                                        for (des_iterator_init(&des_list_it, attribute_value); des_iterator_has_more(&des_list_it); des_iterator_next(&des_list_it)) {
     
    172185                                                uint32_t uuid = de_get_uuid32(element);
    173186                                                switch (uuid) {
    174                                                 case BNEP_UUID_PANU:
    175                                                 case BNEP_UUID_NAP:
    176                                                 case BNEP_UUID_GN:
     187                                                case BLUETOOTH_SERVICE_CLASS_PANU:
     188                                                case BLUETOOTH_SERVICE_CLASS_NAP:
     189                                                case BLUETOOTH_SERVICE_CLASS_GN:
    177190                                                        log_info("SDP Attribute 0x%04x: BNEP PAN protocol UUID: %04x", value_event->attribute_id, uuid);
    178191                                                        sdp_bnep_remote_uuid = uuid;
     
    192205                                        free(str);
    193206                                        break;
    194                                 case SDP_ProtocolDescriptorList: {
     207                                case BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST: {
    195208                                        log_info("SDP Attribute: 0x%04x", value_event->attribute_id);
    196209
     
    210223                                                uuid = de_get_uuid32(element);
    211224                                                switch (uuid) {
    212                                                 case SDP_L2CAPProtocol:
     225                                                case BLUETOOTH_PROTOCOL_L2CAP:
    213226                                                        if (!des_iterator_has_more(&prot_it)) continue;
    214227                                                        des_iterator_next(&prot_it);
    215228                                                        de_element_get_uint16(des_iterator_get_element(&prot_it), &sdp_bnep_l2cap_psm);
    216229                                                        break;
    217                                                 case SDP_BNEPProtocol:
     230                                                case BLUETOOTH_PROTOCOL_BNEP:
    218231                                                        if (!des_iterator_has_more(&prot_it)) continue;
    219232                                                        des_iterator_next(&prot_it);
     
    238251                break;
    239252
    240         case SDP_QUERY_COMPLETE:
     253        case SDP_EVENT_QUERY_COMPLETE:
    241254                handle_sdp_client_record_complete();
    242255                complete_event = (sdp_query_complete_event_t*)event;
     
    246259                }
    247260                else {
     261                        bnep_do_connect = false;
    248262                        log_error("No BNEP service found");
     263                }
     264                if (!bnep_do_connect) {
     265                        // 20秒後 BNEP Query 開始
     266                        bt_state = BT_STATE_BNEP_QUERY_WAIT;
     267                        bt_timer = 20 * 1000;
    249268                }
    250269                break;
     
    269288                        if (packet[2] == HCI_STATE_WORKING) {
    270289                                hci_send_cmd(&hci_write_local_name, bt_localname);
    271                                 /* Send a general query for BNEP Protocol ID */
    272                                 log_info("Start SDP BNEP query.");
    273                                 sdp_general_query_for_uuid(remote_addr, SDP_BNEPProtocol);
     290                                if (bt_bnep_mode == 0) {
     291                                        // 即時 BNEP Query 開始
     292                                        bt_state = BT_STATE_BNEP_QUERY_WAIT;
     293                                        bt_timer = 0;
     294                                }
     295                                else {
     296                                        bt_state = BT_STATE_BNEP_WAIT;
     297                                        bt_timer = -1;
     298                                }
    274299                        }
    275300                        break;
     
    284309
    285310                case HCI_EVENT_COMMAND_COMPLETE:
    286                         if (COMMAND_COMPLETE_EVENT(packet, hci_read_bd_addr)) {
    287                                 bt_flip_addr(event_addr, &packet[6]);
     311                        if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_read_bd_addr)) {
     312                                reverse_bd_addr(&packet[6], event_addr);
    288313                                log_info("BD-ADDR: %s", bd_addr_to_str(event_addr));
    289314
     
    292317                                break;
    293318                        }
    294                         if (COMMAND_COMPLETE_EVENT(packet, hci_write_local_name)) {
    295                                 hci_discoverable_control(1);
     319                        if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_write_local_name)) {
     320                                gap_discoverable_control(1);
    296321                                break;
    297322                        }
     
    301326                        // deny link key request
    302327                        log_info("Link key request");
    303                         bt_flip_addr(event_addr, &packet[2]);
     328                        reverse_bd_addr(&packet[2], event_addr);
    304329                        hci_send_cmd(&hci_link_key_request_negative_reply, &event_addr);
    305330                        break;
     
    308333                        // inform about pin code request
    309334                        log_info("Pin code request - using '0000'");
    310                         bt_flip_addr(event_addr, &packet[2]);
     335                        reverse_bd_addr(&packet[2], event_addr);
    311336                        hci_send_cmd(&hci_pin_code_request_reply, &event_addr, 4, "0000");
    312337                        break;
     
    314339                case HCI_EVENT_USER_CONFIRMATION_REQUEST:
    315340                        // inform about user confirmation request
    316                         log_info("HCI User Confirmation Request with numeric value '%06u'", READ_BT_32(packet, 8));
     341                        log_info("HCI User Confirmation Request with numeric value '%06u'", little_endian_read_32(packet, 8));
    317342                        log_info("HCI User Confirmation Auto accept");
    318343                        break;
     
    320345                case RFCOMM_EVENT_INCOMING_CONNECTION:
    321346                        // data: event (8), len(8), address(48), channel (8), rfcomm_cid (16)
    322                         bt_flip_addr(event_addr, &packet[2]);
     347                        reverse_bd_addr(&packet[2], event_addr);
    323348                        rfcomm_channel_nr = packet[8];
    324                         rfcomm_channel_id = READ_BT_16(packet, 9);
     349                        rfcomm_channel_id = little_endian_read_16(packet, 9);
    325350                        log_info("RFCOMM channel %u requested for %s", rfcomm_channel_nr, bd_addr_to_str(event_addr));
    326351                        rfcomm_accept_connection_internal(rfcomm_channel_id);
     
    333358                        }
    334359                        else {
    335                                 rfcomm_channel_id = READ_BT_16(packet, 12);
    336                                 mtu = READ_BT_16(packet, 14);
     360                                rfcomm_channel_id = little_endian_read_16(packet, 12);
     361                                mtu = little_endian_read_16(packet, 14);
    337362                                log_info("RFCOMM channel open succeeded. New RFCOMM Channel ID %u, max frame size %u", rfcomm_channel_id, mtu);
    338363                        }
     
    347372                        if (packet[2]) {
    348373                                log_info("BNEP channel open failed, status %02x", packet[2]);
     374
     375                                // 30秒後 BNEP Query 開始
     376                                bt_state = BT_STATE_BNEP_QUERY_WAIT;
     377                                bt_timer = 30 * 1000;
    349378                        }
    350379                        else {
    351380                                // data: event(8), len(8), status (8), bnep source uuid (16), bnep destination uuid (16), remote_address (48)
    352                                 bnep_cid = READ_BT_16(packet, 3);
    353                                 uuid_source = READ_BT_16(packet, 5);
    354                                 uuid_dest = READ_BT_16(packet, 7);
    355                                 mtu = READ_BT_16(packet, 9);
    356                                 //bt_flip_addr(remote_addr, &packet[11]);
     381                                bnep_cid = little_endian_read_16(packet, 3);
     382                                uuid_source = little_endian_read_16(packet, 5);
     383                                uuid_dest = little_endian_read_16(packet, 7);
     384                                mtu = little_endian_read_16(packet, 9);
     385                                //reverse_bd_addr(&packet[11], remote_addr);
    357386                                memcpy(&remote_addr, &packet[11], sizeof(bd_addr_t));
    358387                                log_info("BNEP connection open succeeded to %s source UUID 0x%04x dest UUID: 0x%04x, max frame size %u", bd_addr_to_str(event_addr), uuid_source, uuid_dest, mtu);
     
    360389                                btstack_network_up(bnep_cid, (uint8_t *)hci_local_bd_addr(), (uint8_t *)remote_addr);
    361390                                log_info("Network Interface %s activated", btstack_network_get_name(bnep_cid));
     391
     392                                bt_state = BT_STATE_CONNECTED;
     393                                bt_timer = -1;
    362394                        }
    363395                        break;
     
    368400
    369401                case BNEP_EVENT_CHANNEL_CLOSED:
    370                         bnep_cid = READ_BT_16(packet, 2);
     402                        bnep_cid = little_endian_read_16(packet, 2);
    371403                        bt_channel_closed(bnep_cid);
     404
     405                        // 30秒後 BNEP Query 開始
     406                        bt_state = BT_STATE_BNEP_QUERY_WAIT;
     407                        bt_timer = 30 * 1000;
    372408                        break;
    373409
    374410                case BNEP_EVENT_READY_TO_SEND:
    375                         bnep_cid = READ_BT_16(packet, 2);
     411                        bnep_cid = little_endian_read_16(packet, 2);
    376412                        bt_send_packet(bnep_cid);
    377413                        break;
     
    428464}
    429465
    430 void panu_init(void)
     466void bt_init(void)
    431467{
    432468        const hci_transport_t *transport;
     
    437473        service_record_item_t *bnep_service_record_item;
    438474
     475        btstack_network_init(&network_send_packet_callback);
     476
    439477        //hci_dump_open("", HCI_DUMP_PACKETLOGGER);
    440 
    441         log_info("bt初期化...");
    442478
    443479        // start with BTstack init - especially configure HCI Transport
     
    446482
    447483        /* Initialize HCI */
    448         log_info("HCI初期化...");
    449484        transport = hci_transport_usb_instance();
    450485        control = NULL;
     
    455490
    456491        /* Initialize L2CAP */
    457         log_info("L2CAP初期化...");
    458492        l2cap_init();
    459493        l2cap_register_packet_handler(packet_handler);
    460494
    461495        /* Initialise SDP, create record for SPP and register with SDP */
    462         log_info("SDP初期化...");
    463496        sdp_init();
    464497
    465498        /* Initialize RFCOMM */
    466         log_info("RFCOMM初期化...");
    467499        rfcomm_init();
    468500        rfcomm_register_packet_handler(packet_handler);
     
    470502
    471503        /* Initialise BNEP */
    472         log_info("BNEP初期化...");
    473504        bnep_init();
    474505        bnep_register_packet_handler(packet_handler);
    475         bnep_register_service(NULL, BNEP_UUID_PANU, BNEP_MTU_MIN);  /* Minimum L2CAP MTU for bnep is 1691 bytes */
     506        if (bt_bnep_mode == 0) {
     507                bnep_register_service(NULL, BLUETOOTH_SERVICE_CLASS_PANU, BNEP_MTU_MIN);  /* Minimum L2CAP MTU for bnep is 1691 bytes */
     508        }
     509        else {
     510                bnep_register_service(NULL, BLUETOOTH_SERVICE_CLASS_NAP, BNEP_MTU_MIN);  /* Minimum L2CAP MTU for bnep is 1691 bytes */
     511        }
    476512
    477513        memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
     
    482518        bnep_service_record_item = (service_record_item_t *)bnep_service_buffer;
    483519
    484         log_info("SPPサービス登録...");
    485520        sdp_create_spp_service((uint8_t*)&spp_service_record_item->service_record, 1, "RX SPP");
    486521        de_dump_data_element((uint8_t*)spp_service_record_item->service_record);
     
    488523        sdp_register_service_internal(NULL, spp_service_record_item);
    489524
    490         log_info("BNEPサービス登録...");
    491         pan_create_panu_service((uint8_t*)&bnep_service_record_item->service_record, "RX PANU", "RX PANU", BNEP_SECURITY_NONE);
    492         de_dump_data_element((uint8_t*)bnep_service_record_item->service_record);
    493         log_info("PANU SDP service buffer size: %u", (uint16_t)(sizeof(service_record_item_t) + de_get_len((uint8_t*)bnep_service_record_item->service_record)));
     525        if (bt_bnep_mode == 0) {
     526                pan_create_panu_service((uint8_t*)&bnep_service_record_item->service_record, "RX PANU", "RX PANU", BNEP_SECURITY_NONE);
     527                de_dump_data_element((uint8_t*)bnep_service_record_item->service_record);
     528                log_info("PANU SDP service buffer size: %u", (uint16_t)(sizeof(service_record_item_t) + de_get_len((uint8_t*)bnep_service_record_item->service_record)));
     529        }
     530        else {
     531                pan_create_nap_service((uint8_t*)&bnep_service_record_item->service_record, "RX NAP", "RX NAP", BNEP_SECURITY_NONE,
     532                        PAN_NET_ACCESS_TYPE_100MB_ETHERNET, 0x0001312D0/*10Mb/sec*/, NULL, NULL);
     533                de_dump_data_element((uint8_t*)bnep_service_record_item->service_record);
     534                log_info("NAP SDP service buffer size: %u", (uint16_t)(sizeof(service_record_item_t) + de_get_len((uint8_t*)bnep_service_record_item->service_record)));
     535        }
    494536        sdp_register_service_internal(NULL, bnep_service_record_item);
    495537
     
    500542
    501543        /* Turn on the device */
    502         log_info("HCI電源ON...");
    503544        hci_power_control(HCI_POWER_ON);
    504545
     
    506547        sdp_parser_init();
    507548        sdp_parser_register_callback(handle_sdp_client_query_result);
    508 }
    509 
    510 void nap_init(void);
    511 
    512 void bt_init(void)
    513 {
    514         btstack_network_init(&network_send_packet_callback);
    515 
    516         if (bt_bnep_mode == 0) {
    517                 panu_init();
    518         }
    519         else {
    520                 nap_init();
    521         }
    522 
    523         bt_enabled = true;
    524 }
    525 
    526 void bt_task(void)
    527 {
    528         extern void hal_tick_handler();
    529 
    530         if (bt_enabled) {
    531                 hal_tick_handler();
     549
     550        bt_state = BT_STATE_POWER_ON;
     551        bt_timer = -1;
     552}
     553
     554void bt_process(void)
     555{
     556        if (bt_state != BT_STATE_DORMANT) {
    532557                run_loop_execute();
    533558                bt_send_packet(0xffff);
     559        }
     560
     561        if (bt_timer != 0)
     562                return;
     563
     564        switch (bt_state) {
     565        case BT_STATE_BNEP_QUERY_WAIT:
     566                /* Send a general query for BNEP Protocol ID */
     567                log_info("Start SDP BNEP query.");
     568                sdp_general_query_for_uuid(remote_addr, BLUETOOTH_PROTOCOL_BNEP);
     569
     570                bt_state = BT_STATE_BNEP_QUERY;
     571                bt_timer = -1;
     572                break;
     573        default:
     574                bt_timer = -1;
     575                break;
    534576        }
    535577}
     
    592634        hci_close();
    593635
    594         bt_enabled = false;
    595 }
     636        bt_state = BT_STATE_DORMANT;
     637        bt_timer = -1;
     638}
     639
     640void bt_task_on_start(struct task_if_t *task, ID tskid)
     641{
     642}
     643
     644void bt_task_on_end(struct task_if_t *task)
     645{
     646}
     647
     648int bt_task_get_timer(struct task_if_t *task)
     649{
     650        return bt_timer;
     651}
     652
     653void bt_task_progress(struct task_if_t *task, int elapse)
     654{
     655        if (bt_timer == -1)
     656                return;
     657
     658        bt_timer -= elapse;
     659        if (bt_timer < 0)
     660                bt_timer = 0;
     661}
     662
     663void bt_task_process(struct task_if_t *task, enum task_event_t event)
     664{
     665        extern void hal_tick_handler();
     666
     667        switch (event & ~TASK_EVENT_TICK) {
     668        case TASK_EVENT_START:
     669                bt_init();
     670                break;
     671        case TASK_EVENT_TERMINATE:
     672                bt_terminate();
     673                break;
     674        case TASK_EVENT_WAKEUP:
     675        case TASK_EVENT_TIMEOUT:
     676                if (event & TASK_EVENT_TICK)
     677                        hal_tick_handler();
     678                bt_process();
     679                break;
     680        }
     681}
     682
     683struct task_if_t bt_task = {
     684        bt_task_on_start,
     685        bt_task_on_end,
     686        bt_task_get_timer,
     687        bt_task_progress,
     688        bt_task_process,
     689};
Note: See TracChangeset for help on using the changeset viewer.