bttest/rev3.c

Date:
08.07.2004
Author:
Jan Beutel <j.beutel@ieee.org>
Testing application for new BTnode rev3

To use this testing application it is important to lower all buffersizes to a minimum. otherwise the internal 4KB RAM will not be enough. Lower the uart-buffer in NUT-OS (nut/include/dev/usart.h) to: 32 bytes, high-watermark 30 bytes, low-watermark 20 bytes Lower the buffersize in btn-terminal.h file to something like:

 #define MAX_CMDS 10
 #define READLN_BUF 15
 #define HISTORY_DEPTH 3
 #define LEN_CMD_NAME 10
 #define TERMINAL_THREAD_SIZE 128
 
Don't forget to call 'make clean' and 'make install' after changing the h files!

00001 /*
00002  * Copyright (C) 2000-2005 by ETH Zurich
00003  *
00004  * Redistribution and use in source and binary forms, with or without
00005  * modification, are permitted provided that the following conditions
00006  * are met:
00007  *
00008  * 1. Redistributions of source code must retain the above copyright
00009  *    notice, this list of conditions and the following disclaimer.
00010  * 2. Redistributions in binary form must reproduce the above copyright
00011  *    notice, this list of conditions and the following disclaimer in the
00012  *    documentation and/or other materials provided with the distribution.
00013  * 3. Neither the name of the copyright holders nor the names of
00014  *    contributors may be used to endorse or promote products derived
00015  *    from this software without specific prior written permission.
00016  *
00017  * THIS SOFTWARE IS PROVIDED BY ETH ZURICH AND CONTRIBUTORS
00018  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00019  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
00020  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ETH ZURICH
00021  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
00022  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
00023  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
00024  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
00025  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00026  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
00027  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
00028  * SUCH DAMAGE.
00029  *
00030  * For additional information see http://www.ethernut.de/
00031  *
00032  * $Id: rev3.c,v 1.18 2006/03/23 07:22:22 dyerm Exp $
00033  * 
00034  */
00035 
00087 // nut
00088 #include <stdio.h>
00089 #include <io.h>
00090 #include <dev/usartavr.h>
00091 #include <sys/timer.h>
00092 
00093 // btnode hardware
00094 #include <arch/btn-hardware.h>
00095 
00096 // btnode lib
00097 #include <bt/bt_hci_cmds.h>
00098 #include <bt/bt_acl_com.h>
00099 #include <terminal/btn-terminal.h>
00100 //#include <terminal/nut-cmds.h>
00101 #include <hardware/btn-bat.h>
00102 
00103 // chipcon test
00104 #define USED_FROM_BTCMD
00105 #include "cc1000-test.c"
00106 
00107 //misc
00108 #include "program_version.h"
00109 
00110 // prototypes
00111 void _cmd_inq(u_char* arg);
00112 
00113 FILE *uart_terminal;
00114 FILE *bt_uart;
00115 u_char pkt[10];
00116 u_char got;
00117 u_char inbuf[6];
00118 
00119 //terminal init-------------------------------------------------
00120 void init_term(void) {
00121     u_long parameter;
00122 
00123     // initialize UART 1
00124     NutRegisterDevice(&APP_UART, 0, 0);
00125     uart_terminal = fopen(APP_UART.dev_name, "r+");
00126     parameter = 57600;
00127     _ioctl(_fileno(uart_terminal), UART_SETSPEED, &parameter);
00128     parameter = 1;
00129     _ioctl(_fileno(uart_terminal), UART_SETCOOKEDMODE, &parameter);
00130     btn_terminal_init(uart_terminal, "[bttest@rev3]$");
00131 }
00132 
00133 //checking memory--------------------------------------------
00134 #define MAX_NR_ERRORS 5
00135 #define MEM_TEST_BUF_ADDR 0x1100
00136 #define MEM_TEST_BUF_SIZE 0xFFFF - MEM_TEST_BUF_ADDR
00137 
00138 void _print_bits(u_char res) {
00139         u_char i;
00140         for (i=0;i<8;i++) {
00141            if (res&(1<<(7-i))) DEBUGT("1");
00142            else DEBUGT("0");
00143         }
00144 }
00145 
00146 void _print_error(u_short addr, u_char is, u_char exp) {
00147   DEBUGT("error at 0x%.4x (",addr);
00148           _print_bits(addr);
00149           DEBUGT("): is: 0x%.2x (", is);
00150           _print_bits(is);
00151           DEBUGT(") exp: 0x%.2x (", exp);
00152           _print_bits(exp);
00153           DEBUGT(")\n");
00154 }
00155 
00156 void _print_data(u_short addr, u_char value) {
00157   DEBUGT("writing at 0x%.4x (",addr);
00158           _print_bits(addr);
00159           DEBUGT("): 0x%.2x (", value);
00160           _print_bits(value);
00161           DEBUGT(")\n");
00162 }
00163 
00164 void _cmd_mem_on(u_char* arg) {
00165     //set up bank switching
00166     sbi(RAM_CTR_A_DDR, RAM_CTR_A_PIN);
00167     sbi(RAM_CTR_B_DDR, RAM_CTR_B_PIN);
00168     // enable xsram at the very beginning to be able to place .bss and
00169     // .data there
00170     sbi(MCUCR, SRE);
00171     //no buskeeper and no sectoring
00172     outb (XMCRB, 0x00);
00173     // bus-keeper
00174     sbi(XMCRB, XMBK);
00175     //waitstates for upper and lower sector
00176     sbi(MCUCR, SRW10); // 1 cycle befor read-write
00177     cbi(XMCRA, SRW11);
00178 }
00179 
00180 void mem_test_selectBank(u_char i) {
00181     //DEBUGT("bank %d selected\n",i);
00182     if (i&1) sbi(RAM_CTR_A_PORT, RAM_CTR_A_PIN);
00183     else cbi(RAM_CTR_A_PORT, RAM_CTR_A_PIN);
00184     if (i&2) sbi(RAM_CTR_B_PORT, RAM_CTR_B_PIN);
00185     else cbi(RAM_CTR_B_PORT, RAM_CTR_B_PIN);
00186 }
00187 
00188 u_char mem_test_checkMem(void) {
00189     volatile u_char *xbuffer;
00190     xbuffer = (u_char *) MEM_TEST_BUF_ADDR;
00191     u_short i=0; u_char j=0; u_char data;
00192     u_char errors=0;
00193     u_char return_val=0;
00194     data = 0;
00195     for (i = 0; i < MEM_TEST_BUF_SIZE; i++) {
00196         xbuffer[i] = data;
00197         if (xbuffer[i] != data) {
00198           _print_error(i, xbuffer[i], data);
00199           return_val = 1;
00200           if (errors++ > MAX_NR_ERRORS-2) break;
00201         }
00202     }
00203     data = 1;
00204     for (j=0; j<8; j++) {
00205       errors = 0;
00206       for (i = 0; i < MEM_TEST_BUF_SIZE; i++) {
00207         xbuffer[i] = data;
00208         if (xbuffer[i] != data) {
00209            _print_error(i, xbuffer[i], data);
00210            return_val = 1;
00211            if (errors++ > MAX_NR_ERRORS-2) break;
00212         }
00213       }
00214       data = data*2;
00215     }
00216     return return_val;
00217 }
00218 
00219 u_char mem_test_one(void) {
00220     volatile u_char *xbuffer;
00221     u_short res;
00222     xbuffer = (u_char *) MEM_TEST_BUF_ADDR;
00223     // test one: check every bank alone
00224     mem_test_selectBank(0);
00225     res = mem_test_checkMem();
00226     mem_test_selectBank(1);
00227     res += mem_test_checkMem();
00228     mem_test_selectBank(2);
00229     res += mem_test_checkMem();
00230     mem_test_selectBank(3);
00231     res += mem_test_checkMem();
00232     // ok
00233     return res;
00234 }
00235 
00236 u_char mem_test_two(void) {
00237     u_short i;
00238     u_char bank;
00239     volatile u_char *xbuffer;
00240     xbuffer = (u_char *) MEM_TEST_BUF_ADDR;
00241     u_char errors=0;
00242     u_char return_val=0;
00243     // test two: a) fill every bank with special nr to see if banks are disjunct
00244     //DEBUGT("writing data ");
00245     for (bank=0; bank<4; bank++) {
00246         mem_test_selectBank(bank);
00247         for (i = 0; i < MEM_TEST_BUF_SIZE; i++)
00248             xbuffer[i] = 0xf0+bank;
00249     }
00250     //DEBUGT("verifying data\n");
00251     // test two: b) now check to see, if data is still there and valid 
00252     for (bank=0; bank<4; bank++) {     
00253         mem_test_selectBank(bank);
00254         for (i = 0; i < MEM_TEST_BUF_SIZE; i++)    
00255             if (xbuffer[i] != 0xf0+bank) {
00256                _print_error(i, xbuffer[i], 0xf0+bank);
00257                return_val = 1;
00258                if (errors++ > MAX_NR_ERRORS-2) break;
00259             }
00260     }
00261     return return_val;
00262 }
00263 
00264 u_char mem_test_three_four(u_short count_step) {
00265     u_short i;
00266     u_char bank;
00267     u_char data;
00268     volatile u_char *xbuffer;
00269     xbuffer = (u_char *) MEM_TEST_BUF_ADDR;
00270     u_char errors=0;
00271     u_char return_val=0;
00272     //DEBUGT("writing data ");
00273     for (bank=0; bank<4; bank++) {
00274         mem_test_selectBank(bank);
00275         data = bank*5; //start with different data on each bank
00276         errors = 0;
00277         for (i = 0; i < MEM_TEST_BUF_SIZE; i+=count_step) {
00278             xbuffer[i] = data;
00279             if (xbuffer[i] != data) {
00280                _print_error(i, xbuffer[i], bank);
00281                return_val = 1;
00282                if (errors++ > MAX_NR_ERRORS-2) break;
00283             }
00284             data++;
00285         }
00286     }
00287     if (return_val != 0) return 1;
00288     //DEBUGT("verifying data\n");
00289     // test two: b) now check to see, if data is still there and valid   
00290     for (bank=0; bank<4; bank++) {   
00291         mem_test_selectBank(bank);
00292         data = bank*5;
00293         errors = 0;
00294         for (i = 0; i < MEM_TEST_BUF_SIZE; i+=count_step) {
00295               if (xbuffer[i] != data) {
00296                  _print_error(i, xbuffer[i], data);
00297                  return_val = 1;
00298                  if (errors++ > MAX_NR_ERRORS-2) break;
00299               }
00300               data++;
00301             
00302         }
00303     }
00304     return return_val;
00305 }
00306 
00307 u_char mem_test_five(void) {
00308     u_short i;
00309     u_char bank;
00310     volatile u_char *xbuffer;
00311     xbuffer = (u_char *) MEM_TEST_BUF_ADDR;
00312     u_char errors=0;
00313     u_char return_val=0;
00314     //DEBUGT("round 1 0x00,0xff,...\n");
00315     for (bank=0; bank<4; bank++) {
00316         //DEBUGT("writing data ");
00317         mem_test_selectBank(bank);
00318         for (i = 0; i < MEM_TEST_BUF_SIZE; i++)
00319             xbuffer[i] = i%2 ? 0x00: 0xFF;
00320         //DEBUGT("verifying data\n");
00321         for (i = 0; i < MEM_TEST_BUF_SIZE; i++)    
00322             if (xbuffer[i] != (i%2 ? 0x00: 0xFF)) {
00323                  _print_error(i, xbuffer[i], i%2 ? 0x00: 0xFF);
00324                  return_val = 1;
00325                  if (errors++ > MAX_NR_ERRORS-2) break;
00326             }
00327     }
00328     //DEBUGT("round 2 0xff,0x00,...\n");
00329     for (bank=0; bank<4; bank++) {
00330         //DEBUGT("writing data ");
00331         mem_test_selectBank(bank);
00332         for (i = 0; i < MEM_TEST_BUF_SIZE; i++)
00333             xbuffer[i] = i%2 ? 0xFF: 0x00;
00334         //DEBUGT("verifying data\n");
00335         for (i = 0; i < MEM_TEST_BUF_SIZE; i++)    
00336             if (xbuffer[i] != (i%2 ? 0xFF: 0x00)) {
00337                  _print_error(i, xbuffer[i], i%2 ? 0xFF: 0x00);
00338                  return_val = 1;
00339                  if (errors++ > MAX_NR_ERRORS-2) break;
00340             }
00341     }
00342     return return_val;
00343 }
00344 
00345 void _cmd_memtest(u_char* arg) {
00346     u_char test = arg[0]-'0';
00347     u_char res=0;
00348     if (test<7) {
00349       if (test == 1) {
00350          DEBUGT("test one (data bus check)\n");
00351          res = mem_test_one();
00352       } else if (test == 2) {
00353          DEBUGT("test two (bank selecting check)\n");
00354          res = mem_test_two();
00355       } else if (test == 3) {
00356          DEBUGT("test three (address bus high-8-bit check)\n");
00357          res = mem_test_three_four(256);
00358       } else if (test == 4) {
00359          DEBUGT("test four (address bus 16-bit check)\n");
00360          res = mem_test_three_four(1);
00361       } else if (test == 5) {
00362          DEBUGT("test five (memory bit-check on high-8-bit addr)\n");
00363          res = mem_test_five();
00364       }
00365       if (res == 0) {
00366          DEBUGT("test o.k.\n");
00367       } else {
00368          DEBUGT("test error\n");
00369       }
00370     } else
00371       DEBUGT("usage:memtest [1|2|3|4|5]\n");
00372 }
00373 
00374 void _cmd_mem(u_char *arg)
00375 {
00376     u_char res=0;
00377     DEBUGT("\nMEMORY TESTING\n");
00378     DEBUGT("test one (data bus check)\n");
00379     res = mem_test_one();
00380     DEBUGT("test two (bank selecting check)\n");
00381     res += mem_test_two();
00382     DEBUGT("test three (address bus high-8-bit check)\n");
00383     res += mem_test_three_four(256);
00384     DEBUGT("test four (address bus 16-bit check)\n");
00385     res += mem_test_three_four(1);
00386     DEBUGT("test five (memory bit-check on high-8-bit addr)\n");
00387     res += mem_test_five();
00388     if (res == 0) {
00389          DEBUGT("MEMORY TEST O.K.\n");
00390       } else {
00391          DEBUGT("MEMORY TEST ERROR\n");
00392       }
00393 }
00394 
00395 void _cmd_led(u_char *arg){
00396         DEBUGT("\nLED TESTING\n");
00397         DEBUGT("turning ON  -- ");
00398         btn_hardware_config_latch_set(LED0);
00399         DEBUGT("LED0 ");
00400         NutSleep( 300 );
00401         btn_hardware_config_latch_set(LED1);
00402         DEBUGT("LED1 ");
00403         NutSleep( 300 );
00404         btn_hardware_config_latch_set(LED2);
00405         DEBUGT("LED2 ");
00406         NutSleep( 300 );
00407         btn_hardware_config_latch_set(LED3);
00408         DEBUGT("LED3\n");
00409         NutSleep( 300 );
00410         
00411         DEBUGT("turning OFF -- ");
00412         btn_hardware_config_latch_clear(LED0);
00413         DEBUGT("LED0 ");
00414         NutSleep( 300 );
00415         btn_hardware_config_latch_clear(LED1);
00416         DEBUGT("LED1 ");
00417         NutSleep( 300 );
00418         btn_hardware_config_latch_clear(LED2);
00419         DEBUGT("LED2 ");
00420         NutSleep( 300 );
00421         btn_hardware_config_latch_clear(LED3);
00422         DEBUGT("LED3\n");
00423         NutSleep( 300 );
00424 }
00425 
00426 // jtag enable/disable--------------------------------------------
00427 void jtag_off(u_char *arg){
00428     u_char value = MCUCSR | BV(7);  // JTD - JTAG Disable Bit
00429     // ... the application software must write the desired value 
00430     // two times within four cycles
00431     MCUCSR = value;
00432     MCUCSR = value;
00433     DEBUGT("JTAG Disabled\n");
00434 }
00435 
00436 void jtag_on(u_char *arg){
00437     u_char value = MCUCSR & ~BV(7); // JTD - JTAG Disable Bit
00438     // ... the application software must write the desired value 
00439     // two times within four cycles
00440     MCUCSR = value;
00441     MCUCSR = value;
00442     DEBUGT("JTAG Enabled\n");
00443 }
00444 
00445 //bluetooth functions--------------------------------------------
00446 void tristate_bt(u_char *arg){
00447 
00448     DEBUGT("tri-stating Bluetooth lines\n");    
00449     // disabling TXEN for BT uart nr 1 in UCSR1B
00450     cbi ( UCSR1B, TXEN);
00451     // set TX  as input
00452     cbi ( DDRD, 3);
00453     cbi ( PORTD, 3);
00454     // set RX  as input
00455     cbi ( DDRD, 2);
00456     cbi ( PORTD, 2);
00457     // set RTS as input
00458     cbi ( DDRD, 4); //
00459     cbi ( PORTD, 4);
00460     // set CTS as input
00461     cbi ( DDRE, 5); //
00462     cbi ( PORTE, 5);
00463     // set AVR_TDO as input
00464     cbi ( DDRF, 6);
00465     cbi ( PORTF, 6);
00466     // set TMS as input
00467     cbi ( DDRF, 5);
00468     cbi ( PORTF, 5);
00469     // set TCK as input
00470     cbi ( DDRF, 4);
00471     cbi ( PORTF, 4);
00472 }
00473 
00474 void tristate_off_bt(u_char *arg){
00475 
00476     DEBUGT("activating Bluetooth lines\n"); 
00477      // enabling TXEN for BT uart nr 1 in UCSR1B
00478     sbi ( UCSR1B, TXEN);
00479     // set TX  as output
00480     sbi ( DDRD, 3);
00481     // set RX  as input. set up pull ups/downs?
00482     cbi ( DDRD, 2);
00483     // set RTS as output
00484     sbi ( DDRD, 4); //
00485     // set CTS as input. set up pull ups/downs?
00486     cbi ( DDRE, 5); //
00487 }
00488 
00489 void init_bt_uart(void){
00490 
00491     u_long parameter;
00492         
00493     // initialize UART BT
00494     NutRegisterDevice(&BT_UART, 0, 0);
00495     bt_uart = fopen(BT_UART.dev_name, "r+");
00496     
00497     parameter = BT_UART_INITIAL_SPEED;
00498     _ioctl(_fileno(bt_uart), UART_SETSPEED, &parameter);
00499     
00500         // Set parity for uart.
00501     parameter = BT_UART_INITIAL_PARITY;
00502     _ioctl(_fileno(bt_uart), UART_SETPARITY, &parameter);
00503     // Set # databits for uart.
00504     parameter = BT_UART_INITIAL_DATABITS;
00505     _ioctl(_fileno(bt_uart), UART_SETDATABITS, &parameter);
00506     
00507     // Set # stopbits for uart.
00508     parameter = BT_UART_INITIAL_STOPBITS;
00509     _ioctl(_fileno(bt_uart), UART_SETSTOPBITS, &parameter);
00510     
00511     // Set cooked mode to raw for uart.
00512     parameter = 0;
00513     _ioctl(_fileno(bt_uart), UART_SETCOOKEDMODE, &parameter);
00514 
00515     // Set handshake-type for uart.
00516     parameter = BT_UART_INITIAL_FLOWCONTROL;
00517     _ioctl(_fileno(bt_uart), UART_SETFLOWCONTROL, &parameter);
00518 }
00519 
00520 void _cmd_btreboot(u_char *arg){
00521 
00522     DEBUGT("\nSTANDBY FOR BLUETOOTH REBOOT\n");
00523     // tri-state AVR lines
00524     tristate_bt("");
00525     jtag_off("");
00526 
00527     // VCC OFF and RESET to GND
00528     btn_hardware_bt_power( 0 );
00529     DEBUGT("turning power OFF, ");
00530 
00531     btn_hardware_bt_reset( 1 );
00532     DEBUGT("reset, waiting... "); 
00533     NutSleep( 3000 );
00534 
00535     btn_hardware_bt_power( 1 );
00536     DEBUGT("turning power ON\n"); 
00537     NutSleep ( 1000 );
00538     btn_hardware_bt_reset( 0 );
00539     NutSleep ( 1000 );
00540     
00541     // have to leave tristate off for programming
00542     //tristate_off_bt("");
00543     //jtag_on("");
00544     //DEBUGT("Done.\n"); 
00545     }
00546 
00547 void get_from_module(u_char len) {
00548     got=0;
00549     while (got<len){
00550         got += _read(_fileno(bt_uart), inbuf, 1);
00551         DEBUGT(".") ;
00552         //DEBUGT("0x%.2x ",inbuf[0]) ;
00553     }
00554     //DEBUGT("\n");
00555 }
00556 
00557 void get_from_module_addr(void) {
00558     got=0;
00559     while (got<6){
00560         got += _read(_fileno(bt_uart), inbuf+got, 1);
00561     }
00562     while (got!=0) {
00563         got--;
00564         DEBUGT(":%.2x",inbuf[got]);
00565     }   
00566     DEBUGT("\n");
00567 }
00568 
00569 void get_from_module_version(void) {
00570     got=0;
00571     while (got<8){
00572         got += _read(_fileno(bt_uart), inbuf+got, 1);
00573     }
00574     while (got!=0) {
00575         got--;
00576         DEBUGT(":%.2x",inbuf[got]);
00577     }   
00578     DEBUGT("\n");
00579 }
00580 
00581 void _cmd_btinit(u_char* arg) {
00582 
00583     DEBUGT("\nBLUETOOTH TEST\n");
00584     // tri-state AVR lines
00585     tristate_bt("");
00586     jtag_off("");
00587 
00588     // VCC OFF and RESET to GND
00589     btn_hardware_bt_power( 0 );
00590     DEBUGT("turning power OFF, ");
00591 
00592     btn_hardware_bt_reset( 1 );
00593     DEBUGT("reset, waiting... "); 
00594     NutSleep( 3000 );
00595 
00596     btn_hardware_bt_power( 1 );
00597     DEBUGT("turning power ON, "); 
00598     NutSleep ( 1000 );
00599     btn_hardware_bt_reset( 0 );
00600     NutSleep ( 1000 );
00601     
00602     tristate_off_bt("");
00603     jtag_on("");
00604 
00605     // flush uart input buffer
00606     _read(_fileno(bt_uart), 0, 0);
00607 
00608     DEBUGT("\nBLUETOOTH INIT\n");
00609 
00610     //reset pkt
00611     pkt[0] = 0x01;
00612     pkt[1] = 0x03; //ocf
00613     pkt[2] = 0x0C; //ogf shifted by 2
00614     pkt[3] = 0x00; // payload length
00615     _write(_fileno(bt_uart), pkt, 4);
00616     get_from_module(11);
00617     //DEBUGT("-- got 11 --\n");
00618 
00619     // after reset
00620     //DEBUGT("-- reset packet --\n");
00621 
00622     //set event filter
00623     pkt[1] = 0x05;
00624     pkt[3] = 0x01;
00625 
00626     pkt[4] = 0x00;
00627     _write(_fileno(bt_uart), pkt, 5);
00628     get_from_module(7);
00629     //DEBUGT("-- got 7 --\n");
00630 
00631     //conn accept timeout
00632     pkt[1] = 0x16;
00633     pkt[3] = 0x02;
00634 
00635     pkt[4] = 0x40;
00636     pkt[5] = 0x1F;
00637     _write(_fileno(bt_uart), pkt, 6);
00638     get_from_module(7);
00639     //DEBUGT("-- got 7 --\n");
00640 
00641     //page timeout
00642     pkt[1] = 0x18;
00643     pkt[3] = 0x02;
00644     pkt[4] = 0x00;
00645     pkt[5] = 0x20;
00646     _write(_fileno(bt_uart), pkt, 6);
00647     get_from_module(7);
00648     //DEBUGT("-- got 7 --\n");
00649 
00650     //scan timeout
00651     pkt[1] = 0x1A;
00652     pkt[3] = 0x01;
00653     pkt[4] = 0x03;
00654     _write(_fileno(bt_uart), pkt, 5);
00655     get_from_module(7);
00656     //DEBUGT("-- got 7 --\n");
00657 
00658     //read buffersize
00659     pkt[1] = 0x05;
00660     pkt[2] = 0x10;
00661     pkt[3] = 0x00;
00662     _write(_fileno(bt_uart), pkt, 4);
00663     get_from_module(14);
00664     //DEBUGT("-- got 14 --\n");
00665 
00666     //set acl flowcontrol
00667     pkt[1] = 0x31;
00668     pkt[2] = 0x0C;
00669     pkt[3] = 0x01;
00670     pkt[4] = 0x01;
00671     _write(_fileno(bt_uart), pkt, 5);
00672     get_from_module(7);
00673     //DEBUGT("-- got 7 --\n");
00674 
00675     //inquiry type
00676     pkt[1] = 0x45;
00677     _write(_fileno(bt_uart), pkt, 5);
00678     get_from_module(7);
00679     //DEBUGT("-- got 7 --\n");
00680 
00681     DEBUGT("init done\nmy addr: ");
00682         
00683     //read bd addr
00684     pkt[1] = 0x09;
00685     pkt[2] = 0x10;
00686     pkt[3] = 0x00;
00687     _write(_fileno(bt_uart), pkt, 4);
00688     get_from_module(7);
00689     //DEBUGT("-- got 7 --\n");
00690     get_from_module_addr();
00691 
00692     //read local version info
00693     pkt[0] = 0x01; //OGF
00694     pkt[1] = 0x01; //OCF
00695     pkt[2] = 0x10;
00696     pkt[3] = 0x00;
00697     _write(_fileno(bt_uart), pkt, 4);
00698     DEBUGT("hci version found");
00699     get_from_module(7);
00700     //get_from_module(12);
00701     get_from_module_version();
00702     //get_from_module(4);
00703 
00704     //DEBUGT("\n");
00705     //inquiry
00706     pkt[0] = 0x01;
00707     pkt[1] = 0x01;
00708     pkt[2] = 0x04;
00709     pkt[3] = 0x05;
00710     pkt[4] = 0x33;
00711     pkt[5] = 0x8B;
00712     pkt[6] = 0x9E;
00713     pkt[7] = 0x30; //length
00714     pkt[8] = 0x01; //num responses
00715     _write(_fileno(bt_uart), pkt, 9);
00716     DEBUGT("inquiry found: ");
00717     get_from_module(8);
00718     get_from_module(3);
00719     get_from_module_addr(); // inquiry result
00720     get_from_module(8); // inquiry result parameters
00721     get_from_module(10); // command complete
00722 
00723     DEBUGT("\nBLUETOOTH O.K.\n");
00724 }
00725 
00726 void _cmd_inq(u_char* arg) {
00727 
00728        DEBUGT("BLUETOOTH INQUIRY \n");
00729        tristate_off_bt("");
00730        jtag_on("");
00731        //inquiry
00732        pkt[0] = 0x01;
00733        pkt[1] = 0x01;
00734        pkt[2] = 0x04;
00735        pkt[3] = 0x05;
00736        pkt[4] = 0x33;
00737        pkt[5] = 0x8B;
00738        pkt[6] = 0x9E;
00739        pkt[7] = 0x30; //length
00740        pkt[8] = 0x01; //num responses
00741        _write(_fileno(bt_uart), pkt, 9);
00742        DEBUGT("inquiry found: ");
00743        get_from_module(8);
00744        get_from_module(3);
00745        get_from_module_addr(); // inquiry result
00746        get_from_module(8); // inquiry result parameters
00747        get_from_module(10); // command complete
00748        DEBUGT("\nBLUETOOTH INQUIRY O.K. \n");
00749        }
00750 
00751 void _cmd_version(u_char* arg) {
00752 
00753        DEBUGT("BLUETOOTH LOCAL HCI VERSION \n");
00754        tristate_off_bt("");
00755        jtag_on("");
00756        //read local version info
00757        pkt[0] = 0x01; //OGF
00758        pkt[1] = 0x01; //OCF
00759        pkt[2] = 0x10;
00760        pkt[3] = 0x00;
00761        _write(_fileno(bt_uart), pkt, 4);
00762        DEBUGT("hci version found");
00763        get_from_module(7);
00764        //get_from_module(12);
00765        get_from_module_version();
00766        //get_from_module(4);
00767        }
00768 
00769 void _cmd_bat(u_char* arg){
00770     u_int volt = 0;
00771     
00772     DEBUGT("BATTERY TEST\n");
00773     volt = btn_external_power();
00774     if (volt > 0){
00775         DEBUGT("we have external power\n");
00776     }
00777     volt = btn_bat_measure(10);
00778     DEBUGT("voltage is: %d\n", volt);
00779     DEBUGT("BATTERY TEST O.K.\n");
00780     
00781 }
00782 
00783 void _cmd_lpm(u_char* arg){
00784     
00785     DEBUGT("LOW POWER MODES TEST\n");
00786     tristate_bt("");
00787     jtag_off("");
00788 
00789     // BT_VCC OFF and RESET to GND
00790     btn_hardware_bt_power( 0 );
00791     DEBUGT("turned bt power OFF, ");
00792     NutSleep( 3000 );
00793 
00794     // CC1000_VCC OFF and RESET to GND
00795     btn_hardware_cc1000_power( 0 );
00796     DEBUGT("turned cc1000 power OFF, ");
00797     NutSleep( 3000 );
00798 
00799     // IO_VCC OFF and RESET to GND
00800     btn_hardware_io_power( 0 );
00801     DEBUGT("turned io power OFF, ");
00802     NutSleep( 3000 );
00803 
00804 //  btn_hardware_bt_reset( 1 );
00805 //  DEBUGT("BT reset, waiting... "); 
00806 //  NutSleep( 3000 );
00807 //
00808 //  btn_hardware_bt_power( 1 );
00809 //  DEBUGT("turned bt power ON\n"); 
00810 //  NutSleep ( 1000 );
00811 //  btn_hardware_bt_reset( 0 );
00812 //  DEBUGT("BT reset released "); 
00813 //  NutSleep ( 1000 );
00814 
00815     DEBUGT("LOW POWER MODES TEST FINISHED\n");
00816 }
00817 
00818 int main(void)
00819 {
00820     u_long cpu_crystal;
00821     
00822     // terminal initialization
00823     init_term();
00824     DEBUGB("\n# ---------------------------------------------");
00825     DEBUGB("\n# BTnode rev3 System Test (c) 2005 ETH Zurich\n");
00826     DEBUGT("# program version: %s\n", PROGRAM_VERSION);
00827     cpu_crystal = NutGetCpuClock();
00828     DEBUGT("# running on a %u.%04u MHz CPU\n",
00829            (int) (cpu_crystal / 1000000UL), (int) ((cpu_crystal - (cpu_crystal / 1000000UL) * 1000000UL) / 100)
00830         );
00831     DEBUGB("# ---------------------------------------------\n");
00832             
00833     // bt uart
00834     init_bt_uart();    
00835 
00836     // leds off (visible for 100 ms)
00837     NutDelay( 100 );
00838     btn_hardware_config_latch_init();
00839     btn_hardware_config_latch_clear(LED0);
00840     btn_hardware_config_latch_clear(LED1);
00841     btn_hardware_config_latch_clear(LED2);
00842     btn_hardware_config_latch_clear(LED3);
00843 
00844     // ext mem on + setup bank switching
00845     _cmd_mem_on("");
00846     
00847     // register cmds
00848     btn_terminal_register_cmd("memtest", _cmd_memtest);
00849     btn_terminal_register_cmd("mem", _cmd_mem);
00850     btn_terminal_register_cmd("btinit", _cmd_btinit);
00851     btn_terminal_register_cmd("btreboot", _cmd_btreboot);
00852     btn_terminal_register_cmd("inq", _cmd_inq);
00853     btn_terminal_register_cmd("led", _cmd_led);
00854     btn_terminal_register_cmd("ver", _cmd_version);
00855     btn_terminal_register_cmd("bat", _cmd_bat);
00856     btn_terminal_register_cmd("lpm", _cmd_lpm);
00857     cc_test_register_cmds();
00858     
00859     // automatic tests
00860     _cmd_mem("");
00861     _cmd_btreboot("");
00862     _cmd_led("");
00863     _cmd_bat("");
00864 
00865     // main options now: btreset/btpower (for programming) and inq (function)
00866     btn_terminal_run(BTN_TERMINAL_NOFORK, 0);
00867 
00868     return 0;
00869 }
00870 
00871 
00872 
00873 

Generated on Tue Jan 23 21:12:24 2007 for BTnut System Software by doxygen 1.4.7