Subversion Repositories Projects

Compare Revisions

Ignore whitespace Rev 1733 → Rev 1734

/Transportables_Koptertool/branch/PKT_V363a_V088n_MartinR/bluetooth.c
0,0 → 1,1228
/**
* source for the Bluetooth driver
* @file bluetooth.c
* @author Linus Lotz<lotz@in.tum.de>
* @author Salomon Sickert
*/
 
 
 
#include "cpu.h"
#include <string.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include "bluetooth.h"
#include "main.h"
#ifdef HWVERSION3_9
#include "uart1.h"
#include "usart.h"
#include "timer.h"
#include "fifo.h"
#include "error.h"
#include "lcd.h"
#include "eeprom.h"
#include "error.h"
#include "setup.h"
#include "bluetooth.h"
#include "tracking.h"
 
 
//#define SaveMem
 
//
// Baudrate for the UART-connection to the BTM-222 on SQUIRREL
//
 
#define SQUIRREL
 
#ifdef SQUIRREL
#define UART_BAUD_RATE 19200
#endif
 
#ifdef NUT
#define UART_BAUD_RATE 19200
#endif
 
 
typedef enum {
BT_RAW,
BT_DATA,
BT_CMD,
BT_NOECHO,
BT_NOANSWER
} communication_mode_t;
 
#define BT_CMD_TIMEOUT_MS 2000
 
typedef enum {
BT_TEST, // AT
BT_CONNECT, // ATA
BT_DISCONNECT, // ATH
BT_CLEAR_ADDRESS, // ATD0
BT_SET_ADDRESS, // ATD=_____
BT_FIND_DEVICES, // ATF?
BT_DISABLE_AUTOCONNECT, // ATO1
BT_SET_MASTER, // ATR0
BT_SET_SLAVE, // ATR1
BT_SET_PIN, // ATP=1234
BT_SET_2400, // ATL* Baudrate 2400
BT_SET_9600, // ATL1 Baudrate 9600
BT_SET_19200, // ATL2 Baudrate 19200
BT_SET_38400, // ATL3 Baudrate 38400
BT_SET_57600, // ATL4 Baudrate 57600
BT_SET_115200, // ATL5 Baudrate 115200
BT_SET_NOANSWER, // ATQ1 Rückmeldungen aus
BT_SET_NOECHO, // ATE0 ECHO deaktivieren
BT_SET_ANSWER, // ATQ0 Rückmeldungen
BT_SET_ECHO, // ATE1 ECHO aktivieren
BT_SET_DEFAULT, // Defaultwerte setzen
BT_SET_NAME, // Devicename
BT_SET_DISPWRDOWN // disable auto Powerdown
} bt_cmd_t;
 
 
#define IN_FIFO_SIZE 512
 
 
static uint8_t bt_buffer[IN_FIFO_SIZE];
static fifo_t in_fifo;
 
char rx_buffer[RXD_BUFFER_SIZE];
volatile uint8_t rx_len;
volatile uint8_t rx_ready = 0;
uint8_t rx_GPS;
static char start = '$';
static char end = '\n';
 
char data_decode[RXD_BUFFER_SIZE];
volatile uint16_t rx_timeout;
 
 
static bt_mode_t bt_mode = BLUETOOTH_SLAVE;
static communication_mode_t comm_mode = BT_CMD;
 
uint8_t i = 0;
uint8_t NoEcho = 0;
uint8_t NoAnswer = 0;
 
uint8_t bt_devicecount = 0;
 
uint8_t bt_rxerror = 0;
 
device_info device_list[NUTS_LIST];
 
// Set a timeout of Y ms and a Conditon X, which have to be true while timeout
#define while_timeout(X, Y) for(uint16_t __timeout = 0; __timeout++ <= Y && (X); Delay_MS(Y ? 1 : 0))
 
//--------------------------------------------------------------
void Delay_MS(int count)
{
for (int i = 0; i < count; i++)
_delay_ms(1);
}
 
 
//--------------------------------------------------------------
void uart_receive(void)
{
unsigned int uart_data;
 
while (!fifo_is_full(&in_fifo))
{
uart_data = uart1_getc();
 
// USART_puts(".");
 
switch (uart_data & 0xFF00) {
// Framing Error detected, i.e no stop bit detected
case UART_FRAME_ERROR:
#ifdef DEBUG
warn_pgm(PSTR("FRM ERR"));
#endif
bt_rxerror++;
return;
 
// Overrun, a character already presend in the UART UDR register was
// not read by the interrupt handler before the next character arrived,
// one or more received characters have been dropped
//
case UART_OVERRUN_ERROR:
#ifdef DEBUG
warn_pgm(PSTR("OVR ERR"));
#endif
bt_rxerror++;
return;
 
// We are not reading the receive buffer fast enough,
// one or more received character have been dropped
//
case UART_BUFFER_OVERFLOW:
#ifdef DEBUG
warn_pgm(PSTR("BUF ERR"));
#endif
bt_rxerror++;
return;
 
// UART Inputbuffer empty, nothing to do
case UART_NO_DATA:
return;
 
default:
{
fifo_write(&in_fifo, uart_data);
#ifdef DEBUG
USART_putc(uart_data);
#endif
}
}
}
#ifdef DEBUG
warn_pgm(PSTR("FIFO OVR ERR"));
#endif
}
 
 
//--------------------------------------------------------------
static void uart_send(const char *data, const uint8_t length)
{
#ifdef DEBUG
debug_pgm(PSTR("bt_uart_send"));
#endif
 
char echo;
 
lcd_printp_at (i++, 1, PSTR("."), 0);
for (uint8_t i = 0; i < length; i++)
{
 
#ifdef DEBUG
USART_putc((data[i])); //test
#endif
// debug_pgm(PSTR("bt_init_S"));
 
if (uart1_putc(data[i]) == 0)
{
#ifdef DEBUG
warn_pgm(PSTR("UART: Remote not ready"));
#endif
return;
}
 
if (comm_mode == BT_RAW)
_delay_ms(50);
 
if (comm_mode == BT_DATA)
_delay_ms(1);
 
if (comm_mode == BT_NOECHO)
_delay_ms(1);
 
if (comm_mode == BT_CMD)
{
uint8_t x = 0;
for (; x < 3; x++)
{
// // while_timeout(X, Y) for(uint16_t __timeout = 0; __timeout++ <= Y && (X); _delay_ms(Y ? 1 : 0))
// while_timeout(fifo_is_empty(&in_fifo), 200)
for(uint16_t __timeout = 0; __timeout++ <= 200 && (fifo_is_empty(&in_fifo)); _delay_ms(200 ? 1 : 0))
{
uart_receive();
}
 
fifo_read(&in_fifo, &echo);
 
if (echo != data[i]) {
if (uart1_putc(data[i]) == 0)
{
warn_pgm(PSTR ("UART: Remote not ready"));
return;
}
}
else
break;
}
 
if (x == 3)
{
error_putc(data[i]);
error_pgm(PSTR("BT: WRONG ECHO"));
}
}
}
}
 
 
//--------------------------------------------------------------
static uint16_t send_cmd(const bt_cmd_t command, const char *data)
{
uint16_t CommandDelay=0; // nach BTM222 Kommandos verschiedene Verzögerungszeiten bevor es weitergehen kann
 
// _delay_ms(500); // org 500 300 zu wenig
char full_command[20]; // Maximum command size
 
switch (command)
{
case BT_SET_PIN:
strcpy_P(full_command, PSTR("ATP="));
for (uint8_t i = 0; i < bt_pin_length; i++)
{
full_command[i+4] = bt_pin[i];
}
full_command[(bt_pin_length+4)] =0;
CommandDelay = 100; //100ms
break;
 
case BT_SET_DEFAULT:
strcpy_P(full_command, PSTR("ATZ0"));
CommandDelay = 1000;
break;
 
 
case BT_SET_2400:
strcpy_P(full_command, PSTR("ATL*"));
CommandDelay = 100;
break;
 
case BT_SET_9600:
strcpy_P(full_command, PSTR("ATL1"));
CommandDelay = 100;
break;
 
case BT_SET_19200:
strcpy_P(full_command, PSTR("ATL2"));
CommandDelay = 100;
break;
 
case BT_SET_38400:
strcpy_P(full_command, PSTR("ATL3"));
CommandDelay = 100;
break;
 
case BT_SET_57600:
strcpy_P(full_command, PSTR("ATL4"));
CommandDelay = 100;
break;
 
case BT_SET_115200:
strcpy_P(full_command, PSTR("ATL5"));
CommandDelay = 100;
break;
 
case BT_SET_NOANSWER:
strcpy_P(full_command, PSTR("ATQ1"));
CommandDelay = 100;
break;
 
case BT_SET_NOECHO:
strcpy_P(full_command, PSTR("ATE0"));
CommandDelay = 100;
break;
 
case BT_SET_ANSWER:
strcpy_P(full_command, PSTR("ATQ0"));
CommandDelay = 100;
break;
 
case BT_SET_ECHO:
strcpy_P(full_command, PSTR("ATE1"));
CommandDelay = 100;
break;
 
case BT_TEST:
strcpy_P(full_command, PSTR("AT"));
CommandDelay = 100;
break;
 
case BT_CONNECT:
strcpy_P(full_command, PSTR("ATA"));
CommandDelay = 100;
break;
 
case BT_DISCONNECT:
strcpy_P(full_command, PSTR("ATH"));
CommandDelay = 100;
break;
 
case BT_CLEAR_ADDRESS:
strcpy_P(full_command, PSTR("ATD0"));
CommandDelay = 100;
break;
 
case BT_SET_ADDRESS:
strcpy_P(full_command, PSTR("ATD="));
memcpy((full_command + strlen(full_command)), data, 12);
full_command[16] = 0;
CommandDelay = 100;
break;
 
case BT_FIND_DEVICES:
strcpy_P(full_command, PSTR("ATF?"));
CommandDelay = 100;
break;
 
case BT_DISABLE_AUTOCONNECT:
strcpy_P(full_command, PSTR("ATO1"));
CommandDelay = 3500;
break;
 
case BT_SET_MASTER:
strcpy_P(full_command, PSTR("ATR0"));
CommandDelay = 3000;
break;
 
case BT_SET_SLAVE:
strcpy_P(full_command, PSTR("ATR1"));
CommandDelay = 3000;
break;
 
case BT_SET_NAME:
strcpy_P(full_command, PSTR("ATN="));
for (uint8_t i = 0; i < bt_name_len; i++)
{
full_command[i + 4] = bt_name[i];
}
full_command[(bt_name_len + 4)] = 0;
CommandDelay = 100;
break;
 
case BT_SET_DISPWRDOWN:
strcpy_P(full_command, PSTR("ATS1"));
CommandDelay = 100;
break;
 
default:
warn_pgm(PSTR("CMD UNK"));
return false;
}
 
strcat_P(full_command, PSTR("\r"));
 
// throw away your television
uart_receive();
fifo_clear(&in_fifo);
// debug_pgm(PSTR("bt_init3"));
// send command
uart_send(full_command, strlen(full_command));
 
if (command== BT_SET_NOECHO)
{
_delay_ms(CommandDelay);
return true;
}
 
if (command== BT_SET_NOANSWER)
{
_delay_ms(CommandDelay);
return true;
}
 
if (command== BT_SET_ECHO)
{
_delay_ms(CommandDelay);
return true;
}
if (command== BT_SET_ANSWER)
{
_delay_ms(CommandDelay);
return true;
}
// get response
while_timeout(true, BT_CMD_TIMEOUT_MS)
{
uart_receive();
if (fifo_strstr_pgm(&in_fifo, PSTR("OK\r\n")))
{
info_pgm(PSTR("CMD SEND: OK"));
_delay_ms(CommandDelay);
return true;
}
 
if (fifo_strstr_pgm(&in_fifo, PSTR("ERROR\r\n")))
{
#ifdef DEBUG
info_pgm(PSTR("CMD SEND: Error"));
#endif
return false;
}
}
 
#ifdef DEBUG
if (command != BT_TEST)
warn_pgm(PSTR("CMD SEND: TIMEOUT"));
#endif
 
 
return false;
}
 
 
//--------------------------------------------------------------
void test(void)
{
comm_mode = BT_RAW;
for (uint8_t i = 0; i < 2; i++)
if (send_cmd(BT_TEST, NULL))
break;
comm_mode = BT_CMD;
}
 
 
#ifndef SaveMem
 
//--------------------------------------------------------------
static void clean_line(void)
{
while_timeout(true, 50)
uart_receive();
fifo_strstr_pgm(&in_fifo, PSTR("\r\n"));
}
 
static communication_mode_t update_comm_mode(uint16_t timeout_ms)
{
while_timeout(true, timeout_ms)
{
uart_receive();
 
if (fifo_strstr_pgm(&in_fifo, PSTR("DISCONNECT")))
{
clean_line();
test();
comm_mode = BT_CMD;
return comm_mode;
}
 
if (fifo_strstr_pgm(&in_fifo, PSTR("CONNECT")))
{
_delay_ms(100); //don't delete this, else there will be no success!!!!!!!!!
comm_mode = BT_DATA;
return comm_mode;
}
 
if (fifo_strstr_pgm (&in_fifo, PSTR("Time out,Fail to connect!")))
{
clean_line();
#ifdef DEBUG
debug_pgm(PSTR("CONNECT FAILED"));
#endif
test();
comm_mode = BT_CMD;
return comm_mode;
}
}
 
return comm_mode;
}
#endif
 
 
//--------------------------------------------------------------
uint16_t bt_init(void)
{
uint8_t init_error = false;
uint8_t BT_found = 0;
i = 0;
 
set_BTOn();
 
lcd_cls();
lcd_printp_at (0, 0, PSTR("BT initialisieren.."), 0);
// _delay_ms(200);
 
for (uint8_t z = (bt_name_length); z > 0; z--)
{
if (bt_name[z - 1] != ' ')
{
bt_name_len = z;
break;
}
}
 
uart1_init(UART_BAUD_SELECT(57600, F_CPU));
fifo_init(&in_fifo, bt_buffer, IN_FIFO_SIZE);
_delay_ms(100);
// debug_pgm(PSTR("bt_init"));
// uart_receive();
// debug_pgm(PSTR("bt_init1"));
fifo_clear(&in_fifo);
send_cmd(BT_TEST, NULL);
comm_mode = BT_NOECHO;
send_cmd(BT_SET_ECHO, NULL);
send_cmd(BT_SET_ANSWER, NULL);
 
// debug_pgm(PSTR("bt_init2"));
#ifdef DEBUG
debug_pgm(PSTR("Check with 57600"));
#endif
// send_cmd(BT_TEST, NULL); // Schrott löschen
 
if (send_cmd(BT_TEST, NULL)) // Test mit 57600
{
#ifdef DEBUG
debug_pgm(PSTR("BT found 57600 Baud"));
#endif
BT_found = 1;
}
 
if (BT_found == 0)
{
#ifdef DEBUG
debug_pgm(PSTR("Check with 19200"));
#endif
uart1_init(UART_BAUD_SELECT(19200, F_CPU));// Test mit 19200
_delay_ms(100);
send_cmd(BT_TEST, NULL); // Schrott löschen
send_cmd(BT_SET_ANSWER, NULL);
send_cmd(BT_SET_ECHO, NULL);
 
if (send_cmd(BT_TEST, NULL))
{
debug_pgm(PSTR("19200 OK"));
if (send_cmd(BT_TEST, NULL))
{
#ifdef DEBUG
debug_pgm(PSTR("BT found 19200 Baud"));
#endif
BT_found = 2;
}
}
}
 
if (BT_found == 0)
{
#ifdef DEBUG
debug_pgm(PSTR("Check with 9600"));
#endif
uart1_init(UART_BAUD_SELECT(9600, F_CPU));//test mit 9600
_delay_ms(100);
send_cmd(BT_TEST, NULL);
send_cmd(BT_SET_ANSWER, NULL);
send_cmd(BT_SET_ECHO, NULL);
if (send_cmd(BT_TEST, NULL));
{
#ifdef DEBUG
debug_pgm(PSTR("9600 OK"));
#endif
if (send_cmd(BT_TEST, NULL))
{
#ifdef DEBUG
debug_pgm(PSTR("BT found 9600 Baud"));
#endif
BT_found = 3;
}
}
}
 
 
if (BT_found == 0)
{
#ifdef DEBUG
debug_pgm(PSTR("Check with 4800"));
#endif
uart1_init(UART_BAUD_SELECT(4800, F_CPU));//test mit 4800
_delay_ms(100);
send_cmd(BT_TEST, NULL);
send_cmd(BT_SET_ANSWER, NULL);
send_cmd(BT_SET_ECHO, NULL);
if (send_cmd(BT_TEST, NULL));
{
#ifdef DEBUG
debug_pgm(PSTR("4800 OK"));
#endif
if (send_cmd(BT_TEST, NULL))
{
#ifdef DEBUG
debug_pgm(PSTR("BT found 4800 Baud"));
#endif
BT_found = 4;
}
}
}
 
if (BT_found > 0)
{
/* Set comm_mode to CMD */
comm_mode = BT_CMD;
// test();
// if (BTIsSlave==false)
// {
/* Set BTM Baudrate */
if (!(send_cmd(BT_SET_57600, NULL)))
init_error = true;
uart1_init(UART_BAUD_SELECT(57600, F_CPU));
_delay_ms(100);
// test();
/* Clear remote address */
if(!(send_cmd(BT_CLEAR_ADDRESS, NULL)))
init_error = true;
// test();
/* Set BTM to SLAVE */
if (!(send_cmd(BT_SET_SLAVE, NULL)))
init_error = true;
// test();
/* Set BTM PIN */
if(!(send_cmd(BT_SET_PIN, NULL)))
init_error = true;
// test();
/* Set BTM Name */
if(!(send_cmd(BT_SET_NAME, NULL)))
init_error = true;
_delay_ms(300);
// test();
if(!(send_cmd(BT_SET_DISPWRDOWN, NULL)))
init_error = true;
// }
// test();
/* Set BTM Echo aus */
send_cmd(BT_SET_NOECHO, NULL);
// test();
comm_mode = BT_NOECHO;
/* Set BTM Answer aus */
send_cmd(BT_SET_NOANSWER, NULL);
// test();
 
bt_mode = BLUETOOTH_SLAVE;
 
set_BTOff();
 
 
if (!init_error)
{
WriteBTInitFlag(); // Init merken
WriteBTSlaveFlag();
return true;
}
else
return false;
}
else
{
set_BTOff();
return false;
}
 
}
 
 
#ifndef SaveMem
 
//--------------------------------------------------------------
uint16_t bt_set_mode(const bt_mode_t mode)
{
// if (update_comm_mode(0) == BT_DATA) // 30.1.2012 CB
// return false;
 
if (mode == bt_mode)
return true;
 
if (mode == BLUETOOTH_MASTER)
if (send_cmd(BT_SET_MASTER, NULL))
{
bt_mode = BLUETOOTH_MASTER;
// test();
send_cmd(BT_DISABLE_AUTOCONNECT, NULL);
debug_pgm(PSTR("bt_setmode: Master is set"));
WriteBTMasterFlag();
 
 
}
 
if (mode == BLUETOOTH_SLAVE)
{
if (send_cmd(BT_SET_SLAVE, NULL))
{
bt_mode = BLUETOOTH_SLAVE;
debug_pgm(PSTR("bt_setmode: Slave is set"));
}
send_cmd(BT_SET_NOECHO, NULL);
comm_mode = BT_NOECHO;
/* Set BTM Answer aus */
send_cmd(BT_SET_NOANSWER, NULL);
 
bt_mode = BLUETOOTH_SLAVE;
WriteBTSlaveFlag();
}
// test();
return mode == bt_mode;
}
 
 
//--------------------------------------------------------------
uint16_t bt_receive(void *data, uint8_t length, uint16_t timeout_ms)
{
uint8_t rec_length = 0;
uint8_t i = 0;
 
// while_timeout(true, timeout_ms);
for(uint16_t __timeout = 0; __timeout++ <= true && (timeout_ms); _delay_ms(true ? 1 : 0))
{
if (i == length)
return true;
 
uart_receive();
 
if (fifo_is_empty(&in_fifo))
continue;
 
if (update_comm_mode(0) != BT_DATA)
{
#ifdef DEBUG
debug_pgm(PSTR("not connected"));
#endif
return false;
}
// We have a connection
if (timeout_ms == 0)
timeout_ms += 2000;
 
if (fifo_is_empty(&in_fifo))
continue;
 
// Find starting point of packet
if (!rec_length)
{
fifo_read(&in_fifo, (char *)&rec_length);
 
if (rec_length != length)
{
rec_length = 0;
}
else
{
// You've got mail!
timeout_ms += 2000;
}
}
else
{
fifo_read(&in_fifo, (char *)data + i);
i++;
}
}
return false;
}
 
#endif
 
#ifndef SaveMem
 
 
//--------------------------------------------------------------
uint16_t bt_send(void *data, const uint8_t length)
{
if (update_comm_mode(0) == BT_CMD)
return false;
 
uart_send((const char *)&length, 1);
uart_send((char *)data, length);
return (update_comm_mode(0) == BT_DATA);
}
 
 
#ifdef SQUIRREL
 
//--------------------------------------------------------------
uint16_t bt_connect(const char *address)
{
fifo_init(&in_fifo, bt_buffer, IN_FIFO_SIZE);
uart_receive();
fifo_clear(&in_fifo);
 
// Maybe we already disconnected???
if (BT_DATA == update_comm_mode(0))
{
#ifdef DEBUG
debug_pgm(PSTR("We are still connected..."));
#endif
return false;
}
test();
 
 
/*
if (!send_cmd(BT_DISABLE_AUTOCONNECT, address))
return false;
*/
 
test();
#ifdef DEBUG
debug_pgm (PSTR ("SET_ADD"));
#endif
 
if (!send_cmd(BT_SET_ADDRESS, address))
return false;
 
test();
#ifdef DEBUG
debug_pgm (PSTR ("CONNECT"));
#endif
 
if (!send_cmd(BT_CONNECT, NULL))
return false;
#ifdef DEBUG
debug_pgm (PSTR ("WAIT FOR COMM"));
#endif
return (BT_DATA == update_comm_mode(60000));
}
 
 
//--------------------------------------------------------------
uint16_t bt_disconnect(void)
{
 
 
if (BT_CMD == update_comm_mode(0))
{
fifo_clear(&in_fifo);
return true;
}
 
// Switch to online cmd mode
for (uint8_t i = 0; i < 4; i++)
{
const char plus = '+';
uart_send(&plus, 1);
_delay_ms(1000);
}
 
comm_mode = BT_CMD;
 
if (!send_cmd(BT_DISCONNECT, NULL))
return false;
 
// test();
if (!send_cmd(BT_CLEAR_ADDRESS, NULL))
return false;
// test();
 
if (BT_CMD == update_comm_mode(10000))
{
fifo_clear(&in_fifo);
return true;
}
#ifdef DEBUG
debug_pgm(PSTR("Still in DATA??"));
#endif
return false;
 
}
 
/*
 
BTM-222 Softwareversion 4.35
Inquiry Results:
111111111222222222233333333334
01234567890123456789012345678901234567890
 
1 LE091452 0024-2C-BEB0CA
2 E71 c 0024-7C-3EC9B9
 
BTM-222 Softwareversion 6.26
Inquiry Results:
1 E71 c 0024-7C-3EC9B9 N.A.
2 LE091452 0024-2C-BEB0CA N.A.
 
*/
 
 
//--------------------------------------------------------------
void copy_mac(const char *src, char *dst)
{
uint8_t off = 0;
 
for (uint8_t i = 0; i < 40; i++)
{
if (src[i] == '-') if (src[i+3] == '-')// MAC Adresse suchen
{
off = i-4;
break;
}
}
 
for (uint8_t i = 0; i < 14; i++)
{
if (src[i + off] == '-')
off++;
 
dst[i] = src[i + off];
}
}
//--------------------------------------------------------------
void copy_DevName(const char *src, char *dst)
{
uint8_t off = 0;
 
 
for (uint8_t i = 0; i < 14; i++)
{
if (src[i] == ' ') if (src[i+1] == ' ') break; // nach zwei Leerzeichen ist der Name zuende
dst[i] = src[i + off];
}
}
 
//--------------------------------------------------------------
uint16_t bt_discover(char result[8][12])
 
 
{
 
 
// if (!bt_set_mode(BLUETOOTH_MASTER))
// return false;
 
if (!send_cmd(BT_FIND_DEVICES, NULL))
return false;
 
char buffer[255]; //oversized, but who cares?
char *bufferhead = buffer;
uint16_t pos = 0;
uint16_t Timeout = 28000;
uint16_t pos1 = 0;
uint16_t posC = 0;
#ifdef DEBUG
debug_pgm(PSTR("discover2"));
#endif
do
{
uart_receive();
Timeout--;
pos1++;
posC++;
_delay_ms(1);
write_ndigit_number_u(0,5,fifo_getcount(&in_fifo),5,0,0);
if (posC ==1000)
{
lcd_printp_at (i++, 1, PSTR("."), 0);
posC = 0;
 
}
 
 
if (fifo_is_full(&in_fifo)) break;
#ifdef DEBUG
if (fifo_search(&in_fifo, PSTR("Found."))) debug_pgm(PSTR("Suchen ende1"));
#endif
}
 
// while (((Timeout > 0) ||(!fifo_strstr_pgm(&in_fifo, PSTR("Inquiry Results:\r\n")))) && (!fifo_strstr_pgm(&in_fifo, PSTR("Found"))));
while ((Timeout > 0)||(!fifo_strstr_pgm(&in_fifo, PSTR("Inquiry Results:\r\n"))));
#ifdef DEBUG
debug_pgm(PSTR("Suchen ende2"));
 
 
if (Timeout == 0) debug_pgm(PSTR("Timeout"));
 
if (fifo_is_full(&in_fifo)) debug_pgm(PSTR("Fifo Overrun, zuviele BT Devices"));
#endif
while (!fifo_is_empty(&in_fifo))
{
// Get next line
while (!fifo_cmp_pgm(&in_fifo, PSTR("\r\n")))
{
fifo_read(&in_fifo, bufferhead);
bufferhead++;
}
// terminate string
*bufferhead = 0;
 
//reset bufferhead
bufferhead = buffer;
 
if (strlen(buffer) == 0)
continue; //the empty line before end of inquiry
 
if (strstr_P(buffer, PSTR("Inquiry End")))
// if (searchend)
{
fifo_clear(&in_fifo);
// test();
return true;
}
 
 
copy_DevName(&buffer[3],device_list[pos].DevName);
device_list[pos].DevName[14] = 0; // Stringende
 
copy_mac(&buffer[3], device_list[pos].mac);
 
// for (uint16_t i = 0; i < 15; i++)
// {
//
//// USART_putc((device_list[pos].DevName[i]));
// lcd_print_hex((device_list[pos].DevName[i]),0);
// }
// USART_putc('\n');
//
//
// for (uint16_t i = 0; i < 12; i++)
// {
//
// USART_putc((device_list[pos].mac[i]));
//
// }
//
// USART_putc('\n');
// USART_putc('\r');
pos++;
}
 
return false;
}
 
device_info device_list[NUTS_LIST];
 
void bt_downlink_init(void)
{
 
 
fifo_init(&in_fifo, bt_buffer, IN_FIFO_SIZE);
_delay_ms(100);
// debug_pgm(PSTR("bt_init"));
uart_receive();
fifo_clear(&in_fifo);
// send_cmd(BT_TEST, NULL);
debug_pgm(PSTR("Downlink_init Start"));
// if (BTIsSlave == true) // nur Init wenn BT ist Slave
// {
comm_mode = BT_NOECHO;
 
if (!send_cmd (BT_SET_ECHO,NULL)) {
debug_pgm(PSTR("Downlink_init:Couldn't set Echo!"));
 
}
 
comm_mode = BT_CMD;
if (!send_cmd(BT_SET_ANSWER,NULL)) {
debug_pgm(PSTR("Downlink_init:Couldn't set Answer!"));
 
}
// send_cmd(BT_TEST, NULL);
 
if (!bt_set_mode(BLUETOOTH_MASTER)==BLUETOOTH_MASTER)
 
{
// debug_pgm(PSTR("Downlink_init:Couldn't set master!"));
// return;
}
#ifdef DEBUG
debug_pgm(PSTR("Downlink_init:master set is "));
#endif
 
WriteBTMasterFlag(); // Master merken
 
}
 
 
void bt_searchDevice(void) //Bluetoothgeräte suchen
 
{
 
char result[8][12];
 
 
 
for (uint8_t i = 0; i < 8; i++) // alte Liste löschen
for (uint8_t j = 0; j < 12; j++)
result[i][j] = 0;
#ifdef DEBUG
debug_pgm(PSTR("Search Device:BT_discover"));
#endif
if (bt_discover(result))
{
bt_devicecount = 0;
#ifdef DEBUG
debug_pgm(PSTR("Search Device:Search ok"));
#endif
for (uint8_t i = 0; i < 8; i++)
{
if (valid(i))
bt_devicecount++;
else break;
}
}
#ifdef DEBUG
else
 
debug_pgm(PSTR("Search Device:Search failed"));
#endif
// }
 
}
 
 
//--------------------------------------------------------------
uint16_t bt_receiveNMEA(void)
{
 
char received;
static uint8_t line_flag = 1;
static char* ptr_write = rx_buffer;
 
uart_receive();
 
if (fifo_is_empty(&in_fifo))
// continue;
// break;
return true;
 
 
 
if (update_comm_mode(0) != BT_DATA)
{
#ifdef DEBUG
debug_pgm(PSTR("not connected"));
#endif
return false;
}
 
// We have a connection
// if (timeout_ms == 0)
// timeout_ms += 2000;
 
if (fifo_is_empty(&in_fifo))
// continue;
// break;
return true;
 
fifo_read(&in_fifo, &received);
// Find starting point of packet
if (rx_ready == 0)
{
if ((received == start) && line_flag)
{ // start '$'
line_flag = 0; // New line has begun
ptr_write = rx_buffer; // Begin at start of buffer
rx_len = 0;
}
if (line_flag == 0)
{ // Are we receiving a line?
*ptr_write = received; // Add current byte
rx_len++;
 
// GPS Datensatzende
 
if (received == end)
{ // End of MK-GPS or NMEA-line?
line_flag = 1; // Yes, start new line
rx_ready = 1; // Lock buffer until line has been processed
}
 
 
}
 
ptr_write++;
if(rx_len == RXD_BUFFER_SIZE) line_flag = 1; // Line too long? Try again
}//if (rx_ready == 0)
return true;
}
//
// return false;
//}
 
//#endif
 
 
 
 
#endif
#endif
#endif