btstreamer/streamer/btstreamer.c

Date:

2004/04/18 21:37:09

Author:

Mathias Payer <payerm@student.ethz.ch>

Example application to show the use of the bt stack

/*
 * Copyright (C) 2000-2005 by ETH Zurich
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY ETH ZURICH AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ETH ZURICH
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * For additional information see http://www.ethernut.de/
 *
 * $Id: btstreamer.c,v 1.19 2007/02/15 16:30:51 freckle Exp $
 * 
 */

#ifdef __BTN_UNIX__
#include <dev/unix_devs.h>
#include <unistd.h>
#endif

#ifdef __linux__
#include <sys/timeb.h>
#else
struct timeb {
    long time;
    long millitm;
};
#endif

#include <string.h>
#include <io.h>
#include <stdlib.h>
#include <dev/debug.h>
#include <sys/timer.h>
#include <sys/event.h>
#include <dev/uartavr.h>
#include <dev/usartavr.h>
#include <bt/bt_hci_cmds.h>
#include <hardware/btn-hardware.h>
#include <sys/types.h>
#include <led/btn-led.h>
#include <debug/toolbox.h>

#define HCI_MAX_ACL_DATA_PKT    0x08

#define HCI_MAX_SCO_DATA_PKT    0x01

#define HCI_PACKET_TYPE BT_HCI_PACKET_TYPE_DM3

// Average of HIST_SIZE measurements will be printed.
#define HIST_SIZE   100

//Global variables on the heap
struct btstack *stack;
struct bt_hci_inquiry_result inqres[5];
struct bt_hci_pkt_acl *aclpkt;

bt_hci_con_handle_t THE_handle;
HANDLE table_changed_event;


void con_table_cb(u_char type, u_char reason, bt_hci_con_handle_t con_handle, void* cb_arg)
{ 
    printf("\nconnection table changed!\n");
    switch (type) {
        case BT_HCI_MY_ROLE_MASTER:
            printf("CB: My role switched to master (%d)\n",con_handle);
            break;
        case BT_HCI_MY_ROLE_SLAVE:
            printf("CB: My role switched to slave (%d)\n",con_handle);
            break;
        case BT_HCI_CONNECTION:
            printf("CB: Connection opened (%d)\n",con_handle);
            THE_handle = con_handle;
            NutEventPostAsync(&table_changed_event);
            break;
        case BT_HCI_DISCONNECTION:
            printf("CB: Disconnected (%d)\n",con_handle);
            break;
        default:
            printf("Illegal type entered! (%d)\n",type);
    }
}

int myftime( struct timeb *pt){

#ifdef __AVR_ATmega128__
    pt->time = NutGetSeconds();
    pt->millitm = NutGetMillis() % 1000;
    return 0;
#endif

#ifdef __APPLE__
    pt->time = time( NULL );
    pt->millitm = 0;
    return 0;
#endif

#ifdef __linux__
    return ftime( pt );
#endif

}


int main(void)
{
    long retval;
    long read[3];
    struct timeb times[2];
    long timediff; 
    u_short history[HIST_SIZE];
    u_short counter;
    long histcounter;
    u_long myTime;
    u_long slaveTime;
    
    // serial baud rate
    u_long baud = 57600;
    char name[64];
    bt_addr_t addr;
    u_char i, nr_devices, dataRead;
    bt_hci_con_handle_t con_handle;

    // hardware init
    btn_hardware_init();
    btn_led_init(1);
    
    // init app uart
    NutRegisterDevice(&APP_UART, 0, 0);
    freopen(APP_UART.dev_name, "r+", stdout);
    _ioctl(_fileno(stdout), UART_SETSPEED, &baud);
    
    // Debug-Output
    printf("Main initialization about to start...\n");
    
    // bluetooth module on (takes a while)
    btn_hardware_bt_on();

    // Start the stack and let the initializaiton begin
    stack = bt_hci_init(&BT_UART);
    
    
    // add connection handling to allow role change
    bt_hci_register_con_table_cb(stack, &con_table_cb, NULL);
    
    // reserve data acl pkt
    aclpkt =(struct bt_hci_pkt_acl *) malloc( 200 );
    
    // From now on the stack should be working...
    
    strcpy(name, "BT-Streamer");
    retval = bt_hci_write_local_name(stack, BT_HCI_SYNC, (u_char*) name);
    printf("Setting the btname: %ld\n", retval);
    
    retval = bt_hci_read_local_name(stack, BT_HCI_SYNC, (u_char*) name, 64);
    printf("Getting the btname: %ld ('%s')\n", retval, name);
    
    bt_hci_get_local_bt_addr(stack, addr);
    printf("Getting the local address bt_addr: "ADDR_FMT"\n", ADDR(addr));
    
    retval = bt_hci_read_connection_accept_timeout(stack, BT_HCI_SYNC);
    printf("read_connection_accept_timeout: (0x%lX * 0.625 msec)\n", retval);
    
    retval = bt_hci_read_page_timeout(stack, BT_HCI_SYNC);
    printf("read_page_timeout: (0x%lX * 0.625 msec)\n", retval);
    
    retval = bt_hci_read_scan_enable(stack, BT_HCI_SYNC);
    switch (retval) {
        case BT_HCI_SCAN_MODE_OFF:
            printf("read_scan_enable: %ld (BT_HCI_SCAN_MODE_OFF)\n", retval);
            break;
        case BT_HCI_SCAN_MODE_INQUIRY:
            printf("read_scan_enable: %ld (BT_HCI_SCAN_MODE_INQUIRY)\n", retval);
            break;
        case BT_HCI_SCAN_MODE_PAGE:
            printf("read_scan_enable: %ld (BT_HCI_SCAN_MODE_PAGE)\n", retval);
            break;
        case BT_HCI_SCAN_MODE_INQUIRY_PAGE:     
            printf("read_scan_enable: %ld (BT_HCI_SCAN_MODE_INQUIRY_PAGE)\n", retval);
            break;
        default:
            printf("read_scan_enable: %ld (error)\n", retval);
    }
    
    //cod = bt_hci_read_local_cod(stack, BT_HCI_SYNC);
    //printf("Reading local COD: 0x%lX\n",cod);
    
    //retval = bt_hci_write_local_cod(stack, BT_HCI_SYNC, cod);
    //printf("Writing local COD: %ld, 0x%lX\n",retval,cod);
    
    //retval = bt_hci_write_default_link_policy_settings(stack, BT_HCI_SYNC, BT_HCI_LINK_POLICY_ROLE_SWITCH);
    //printf("Change default link policy: %ld\n", retval);
    
    printf("Starting an inquiry inside the application (may take some time...):\n");
    // duration to wait for devices, max. number of devies to find
    retval = bt_hci_inquiry(stack, BT_HCI_SYNC, 0x08, 0x5, inqres);
    printf("Inquiry: %ld\n", retval);
    if (retval<0) retval=0;
    
    nr_devices = retval;
    for (i=0; i<nr_devices; i++) {
        printf("Device [%d]: %2.x:%2.x:%2.x:%2.x:%2.x:%2.x (Class of device: 0x%lX)\n", i, inqres[i].bdaddr[5], inqres[i].bdaddr[4], inqres[i].bdaddr[3], inqres[i].bdaddr[2], inqres[i].bdaddr[1], inqres[i].bdaddr[0], inqres[i].cod);
        printf("Now we try to get the name of this device... (may take a moment)\n");
        // Set default as 0-string
        name[0]='\0';
        retval = bt_hci_remote_name_request(stack, inqres[i].bdaddr, inqres[i].clock_offset, inqres[i].page_scan_rep_mode, name, 64);
        printf("Remote name request: '%s', Ret.Value: %ld Clock Offset: %d\n", name, retval, inqres[i].clock_offset);
        if (strncmp(name, "BT-Receiver", 11)==0) {
            printf("Ok, we found a device that is capable to receive streamed data.\n");
            printf("Now we try to open a connection to this device...\n");
            retval = bt_hci_create_connection(stack, BT_HCI_SYNC, inqres[i].bdaddr, BT_HCI_PACKET_TYPE_DH3, inqres[i].page_scan_rep_mode, inqres[i].clock_offset, BT_HCI_ROLE_SWITCH_MASTER);
            printf("Open connection: %ld\n", retval);
            
            read[0] = 0;
            read[1] = 0;
            read[2] = 0;
            if (retval>=0) {
                printf("Connection accepted!\n");
                // hooray, a connection exists, now let's do some mischief with it!
                con_handle = retval;
                
                retval = bt_hci_write_link_policy_settings(stack, BT_HCI_SYNC, con_handle, BT_HCI_LINK_POLICY_ROLE_SWITCH);
                printf("Set link policy parameters: %ld\n", retval);

                printf("Ready to send data!\n");
                
                // Set pkt. to smth ;)
                for (dataRead=0; dataRead<183; dataRead++)
                    aclpkt->payload[dataRead] = dataRead-2;
                
                // Data-Payload of the packet
                dataRead=181;
                
                // Init History
                for (counter=0; counter<HIST_SIZE; counter++)
                    history[counter]=0;
                    
                histcounter=0;
                
                // get time in secs + millis
                retval = myftime(&times[0]);
                if (retval!=0)
                    printf("Error reading time: %ld\n", retval);

                while (1) {
                    // fake acl header
                    aclpkt->payload[0] = dataRead + 2; // len - hdr
                    aclpkt->payload[1] = 0;
                    aclpkt->payload[2] = 2;
                    aclpkt->payload[3] = 0;
                    
                    read[0]++;
                    read[1]++;
                    // Now send the pkt (stack, con_handle, length, pkt with payload)
                    //printf("Trying to send a pkt!\n"); // 
                    retval = bt_hci_send_acl_pkt(stack, con_handle, HCI_PB_FIRST_FRAGMENT, HCI_BC_UNICAST, dataRead+2+HCI_ACL_DATA_PKT_HDR, aclpkt);
                    if (retval!=0)
                        printf("Error in send pkt: %ld\n", retval);
                    
                    if (read[0]==10) {
                        retval = myftime(&times[1]);
                        if (retval!=0)
                            printf("Error reading time: %ld\n", retval);
                        
                        // For double:
                        //timediff = 10*181/(times[1].time - times[0].time + (double)(times[1].millitm - times[0].millitm)/1000);
                        
                        // For milliseconds (therefore data * 1000!)
                        timediff = (long) 10*183*1000 / ((times[1].time - times[0].time)*1000 + times[1].millitm - times[0].millitm);
                        times[0] = times[1];
                        history[histcounter++%HIST_SIZE]=timediff;
                        
                        timediff = 0;
                        for (counter=0; counter<HIST_SIZE; counter++)
                            timediff+=history[counter];
    
                        timediff = timediff / HIST_SIZE;
                        
                        myTime = bt_hci_read_clock( stack, BT_HCI_SYNC, 0, 0, NULL, NULL);
                        // retval = bt_hci_read_clock( stack, BT_HCI_SYNC, 1, con_handle, &slaveTime, 0);
                        // _bt_hci_debug_uart = 1;
                        retval = bt_hci_read_clock_offset( stack, BT_HCI_SYNC, con_handle);
                        // _bt_hci_debug_uart = 0;
                        if (retval < 16484 )
                            slaveTime = myTime + retval;
                        else
                            slaveTime = myTime + retval - 32768;
                        printf("%.6lu %.6lu %.6lu \r", myTime, slaveTime, retval);
                       // printf("%.6lu %.6lu %.6lu - Datarate: %.6ld byte/s, packets send: %.6ld - time: %ld\r", myTime, slaveTime, retval, timediff, read[1], times[0].time);
                        read[0]=0;
                    }

                }
                // now that we have the connection, let's disconnect again!
                printf("Now we disconnect again!\n");
                retval = bt_hci_disconnect(stack, BT_HCI_SYNC, con_handle, BT_HCI_DISCONNECT_USER_ENDED);
                printf("Disconnect: %ld\n", retval);
            }
        }
    }
    
    printf("Done. Entering endless loop...\n");
    while (1) {

    }
    return 0;
}

---

!!! Dieses Dokument stammt aus dem ETH Web-Archiv und wird nicht mehr gepflegt !!!
!!! This document is stored in the ETH Web archive and is no longer maintained !!!