WebSVN - Projects - Blame - /Transportables_Koptertool/branch/GPL_PKT_V3_5_8b

Rev	Author	Line No.	Line
1515	-	1	/**
		2	* source for the Bluetooth driver
		3	* @file bluetooth.c
		4	* @author Linus Lotz<lotz@in.tum.de>
		5	* @author Salomon Sickert
		6	*/
		7
		8
		9
		10	#include "cpu.h"
		11	#include <string.h>
		12	#include <util/delay.h>
		13	#include "bluetooth.h"
		14	#include "main.h"
		15	#ifdef HWVERSION3_9
		16	#include "uart1.h"
		17	#include "usart.h"
		18	#include "fifo.h"
		19	#include "error.h"
		20	#include "lcd.h"
		21	#include "eeprom.h"
		22	#include "error.h"
		23	#include "setup.h"
		24
		25
		26	//#define SaveMem
		27
		28	//
		29	// Baudrate for the UART-connection to the BTM-222 on SQUIRREL
		30	//
		31
		32	#define SQUIRREL
		33
		34	#ifdef SQUIRREL
		35	#define UART_BAUD_RATE 19200
		36	#endif
		37
		38	#ifdef NUT
		39	#define UART_BAUD_RATE 19200
		40	#endif
		41
		42
		43	typedef enum {
		44	BT_RAW,
		45	BT_DATA,
		46	BT_CMD,
		47	BT_NOECHO,
		48	BT_NOANSWER
		49	} communication_mode_t;
		50
		51	#define BT_CMD_TIMEOUT_MS 2000
		52
		53	typedef enum {
		54	BT_TEST, // AT
		55	BT_CONNECT, // ATA
		56	BT_DISCONNECT, // ATH
		57	BT_CLEAR_ADDRESS, // ATD0
		58	BT_SET_ADDRESS, // ATD=_____
		59	BT_FIND_DEVICES, // ATF?
		60	BT_DISABLE_AUTOCONNECT, // ATO1
		61	BT_SET_MASTER, // ATR0
		62	BT_SET_SLAVE, // ATR1
		63	BT_SET_PIN, // ATP=1234
		64	BT_SET_57600, // ATL4 Baudrate 57600
		65	BT_SET_NOANSWER, // ATQ1 Rückmeldungen aus
		66	BT_SET_NOECHO, // ATE0 ECHO deaktivieren
		67	BT_SET_ANSWER, // ATQ0 Rückmeldungen
		68	BT_SET_ECHO, // ATE1 ECHO aktivieren
		69	BT_SET_DEFAULT, // Defaultwerte setzen
		70	BT_SET_NAME, // Devicename
		71	BT_SET_DISPWRDOWN // disable auto Powerdown
		72	} bt_cmd_t;
		73
		74	#ifdef SQUIRREL
		75	#define IN_FIFO_SIZE 100
		76	#endif
		77
		78	#ifdef NUT
		79	#define IN_FIFO_SIZE 65
		80	#endif
		81
		82	static uint8_t bt_buffer[IN_FIFO_SIZE];
		83	static fifo_t in_fifo;
		84
		85	static bt_mode_t bt_mode = BLUETOOTH_SLAVE;
		86	static communication_mode_t comm_mode = BT_CMD;
		87
		88	uint8_t i = 0;
		89	uint8_t NoEcho = 0;
		90	uint8_t NoAnswer = 0;
		91
		92
		93
		94	// Set a timeout of Y ms and a Conditon X, which have to be true while timeout
		95	#define while_timeout(X, Y) for(uint16_t __timeout = 0; __timeout++ <= Y && (X); Delay_MS(Y ? 1 : 0))
		96
		97	//--------------------------------------------------------------
		98	void Delay_MS(int count)
		99	{
		100	for (int i = 0; i < count; i++)
		101	_delay_ms(1);
		102	}
		103
		104
		105	//--------------------------------------------------------------
		106	static void uart_receive(void)
		107	{
		108	unsigned int uart_data;
		109
		110	while (!fifo_is_full(&in_fifo))
		111	{
		112	uart_data = uart1_getc();
		113
		114	// USART_puts(".");
		115
		116	switch (uart_data & 0xFF00) {
		117	// Framing Error detected, i.e no stop bit detected
		118	case UART_FRAME_ERROR:
		119	#ifdef DEBUG
		120	warn_pgm(PSTR("FRM ERR"));
		121	#endif
		122	return;
		123
		124	// Overrun, a character already presend in the UART UDR register was
		125	// not read by the interrupt handler before the next character arrived,
		126	// one or more received characters have been dropped
		127	//
		128	case UART_OVERRUN_ERROR:
		129	#ifdef DEBUG
		130	warn_pgm(PSTR("OVR ERR"));
		131	#endif
		132	return;
		133
		134	// We are not reading the receive buffer fast enough,
		135	// one or more received character have been dropped
		136	//
		137	case UART_BUFFER_OVERFLOW:
		138	#ifdef DEBUG
		139	warn_pgm(PSTR("BUF ERR"));
		140	#endif
		141	return;
		142
		143	// UART Inputbuffer empty, nothing to do
		144	case UART_NO_DATA:
		145	return;
		146
		147	default:
		148	{
		149	fifo_write(&in_fifo, uart_data);
		150	// USART_putc(uart_data);
		151	}
		152	}
		153	}
		154	#ifdef DEBUG
		155	warn_pgm(PSTR("FIFO OVR ERR"));
		156	#endif
		157	}
		158
		159
		160	//--------------------------------------------------------------
		161	static void uart_send(const char *data, const uint8_t length)
		162	{
		163	#ifdef DEBUG
		164	debug_pgm(PSTR("bt_uart_send"));
		165	#endif
		166
		167	char echo;
		168
		169	lcd_printp_at (i++, 1, PSTR("."), 0);
		170	for (uint8_t i = 0; i < length; i++)
		171	{
		172
		173	#ifdef DEBUG
		174	USART_putc((data[i])); //test
		175	#endif
		176	// debug_pgm(PSTR("bt_init_S"));
		177
		178	if (uart1_putc(data[i]) == 0)
		179	{
		180	#ifdef DEBUG
		181	warn_pgm(PSTR("UART: Remote not ready"));
		182	#endif
		183	return;
		184	}
		185
		186	if (comm_mode == BT_RAW)
		187	_delay_ms(50);
		188
		189	if (comm_mode == BT_DATA)
		190	_delay_ms(1);
		191
		192	if (comm_mode == BT_NOECHO)
		193	_delay_ms(1);
		194
		195	if (comm_mode == BT_CMD)
		196	{
		197	uint8_t x = 0;
		198	for (; x < 3; x++)
		199	{
		200	// // while_timeout(X, Y) for(uint16_t __timeout = 0; __timeout++ <= Y && (X); _delay_ms(Y ? 1 : 0))
		201	// while_timeout(fifo_is_empty(&in_fifo), 200)
		202	for(uint16_t __timeout = 0; __timeout++ <= 200 && (fifo_is_empty(&in_fifo)); _delay_ms(200 ? 1 : 0))
		203	{
		204	uart_receive();
		205	}
		206
		207	fifo_read(&in_fifo, &echo);
		208
		209	if (echo != data[i]) {
		210	if (uart1_putc(data[i]) == 0)
		211	{
		212	warn_pgm(PSTR ("UART: Remote not ready"));
		213	return;
		214	}
		215	}
		216	else
		217	break;
		218	}
		219
		220	if (x == 3)
		221	{
		222	error_putc(data[i]);
		223	error_pgm(PSTR("BT: WRONG ECHO"));
		224	}
		225	}
		226	}
		227	}
		228
		229
		230	//--------------------------------------------------------------
		231	static uint16_t send_cmd(const bt_cmd_t command, const char *data)
		232	{
		233	_delay_ms(500); // org 500 300 zu wenig
		234	char full_command[20]; // Maximum command size
		235
		236	switch (command)
		237	{
		238	case BT_SET_PIN:
		239	strcpy_P(full_command, PSTR("ATP="));
		240	for (uint8_t i = 0; i < bt_pin_length; i++)
		241	{
		242	full_command[i+4] = bt_pin[i];
		243	}
		244	full_command[(bt_pin_length+4)] =0;
		245	break;
		246
		247	case BT_SET_DEFAULT:
		248	strcpy_P(full_command, PSTR("ATZ0"));
		249	break;
		250
		251	case BT_SET_57600:
		252	strcpy_P(full_command, PSTR("ATL4"));
		253	break;
		254
		255	case BT_SET_NOANSWER:
		256	strcpy_P(full_command, PSTR("ATQ1"));
		257	break;
		258
		259	case BT_SET_NOECHO:
		260	strcpy_P(full_command, PSTR("ATE0"));
		261	break;
		262
		263	case BT_SET_ANSWER:
		264	strcpy_P(full_command, PSTR("ATQ0"));
		265	break;
		266
		267	case BT_SET_ECHO:
		268	strcpy_P(full_command, PSTR("ATE1"));
		269	break;
		270
		271	case BT_TEST:
		272	strcpy_P(full_command, PSTR("AT"));
		273	break;
		274
		275	case BT_CONNECT:
		276	strcpy_P(full_command, PSTR("ATA"));
		277	break;
		278
		279	case BT_DISCONNECT:
		280	strcpy_P(full_command, PSTR("ATH"));
		281	break;
		282
		283	case BT_CLEAR_ADDRESS:
		284	strcpy_P(full_command, PSTR("ATD0"));
		285	break;
		286
		287	case BT_SET_ADDRESS:
		288	strcpy_P(full_command, PSTR("ATD="));
		289	memcpy((full_command + strlen(full_command)), data, 12);
		290	full_command[16] = 0;
		291	break;
		292
		293	case BT_FIND_DEVICES:
		294	strcpy_P(full_command, PSTR("ATF?"));
		295	break;
		296
		297	case BT_DISABLE_AUTOCONNECT:
		298	strcpy_P(full_command, PSTR("ATO1"));
		299	break;
		300
		301	case BT_SET_MASTER:
		302	strcpy_P(full_command, PSTR("ATR0"));
		303	break;
		304
		305	case BT_SET_SLAVE:
		306	strcpy_P(full_command, PSTR("ATR1"));
		307	break;
		308
		309	case BT_SET_NAME:
		310	strcpy_P(full_command, PSTR("ATN="));
		311	for (uint8_t i = 0; i < bt_name_len; i++)
		312	{
		313	full_command[i + 4] = bt_name[i];
		314	}
		315	full_command[(bt_name_len + 4)] = 0;
		316	break;
		317
		318	case BT_SET_DISPWRDOWN:
		319	strcpy_P(full_command, PSTR("ATS1"));
		320	break;
		321
		322	default:
		323	warn_pgm(PSTR("CMD UNK"));
		324	return false;
		325	}
		326
		327	strcat_P(full_command, PSTR("\r"));
		328
		329	// throw away your television
		330	uart_receive();
		331	fifo_clear(&in_fifo);
		332	// debug_pgm(PSTR("bt_init3"));
		333	// send command
		334	uart_send(full_command, strlen(full_command));
		335
		336	if (command== BT_SET_ECHO)
		337	return true;
		338
		339	if (command== BT_SET_ANSWER)
		340	return true;
		341
		342	// get response
		343	while_timeout(true, BT_CMD_TIMEOUT_MS)
		344	{
		345	uart_receive();
		346	if (fifo_strstr_pgm(&in_fifo, PSTR("OK\r\n")))
		347	{
		348	info_pgm(PSTR("CMD SEND: OK"));
		349	return true;
		350	}
		351
		352	if (fifo_strstr_pgm(&in_fifo, PSTR("ERROR\r\n")))
		353	{
		354	#ifdef DEBUG
		355	info_pgm(PSTR("CMD SEND: Error"));
		356	#endif
		357	return false;
		358	}
		359	}
		360
		361	#ifdef DEBUG
		362	if (command != BT_TEST)
		363	warn_pgm(PSTR("CMD SEND: TIMEOUT"));
		364	#endif
		365
		366
		367	return false;
		368	}
		369
		370
		371	//--------------------------------------------------------------
		372	void test(void)
		373	{
		374	comm_mode = BT_RAW;
		375	for (uint8_t i = 0; i < 3; i++)
		376	if (send_cmd(BT_TEST, NULL))
		377	break;
		378	comm_mode = BT_CMD;
		379	}
		380
		381
		382	#ifndef SaveMem
		383
		384	//--------------------------------------------------------------
		385	static void clean_line(void)
		386	{
		387	while_timeout(true, 50)
		388	uart_receive();
		389	fifo_strstr_pgm(&in_fifo, PSTR("\r\n"));
		390	}
		391
		392	static communication_mode_t update_comm_mode(uint16_t timeout_ms)
		393	{
		394	while_timeout(true, timeout_ms)
		395	{
		396	uart_receive();
		397
		398	if (fifo_strstr_pgm(&in_fifo, PSTR("DISCONNECT")))
		399	{
		400	clean_line();
		401	test();
		402	comm_mode = BT_CMD;
		403	return comm_mode;
		404	}
		405
		406	if (fifo_strstr_pgm(&in_fifo, PSTR("CONNECT")))
		407	{
		408	_delay_ms(100); //don't delete this, else there will be no success!!!!!!!!!
		409	comm_mode = BT_DATA;
		410	return comm_mode;
		411	}
		412
		413	if (fifo_strstr_pgm (&in_fifo, PSTR("Time out,Fail to connect!")))
		414	{
		415	clean_line();
		416	#ifdef DEBUG
		417	debug_pgm(PSTR("CONNECT FAILED"));
		418	#endif
		419	test();
		420	comm_mode = BT_CMD;
		421	return comm_mode;
		422	}
		423	}
		424
		425	return comm_mode;
		426	}
		427	#endif
		428
		429
		430	//--------------------------------------------------------------
		431	uint16_t bt_init(void)
		432	{
		433	uint8_t init_error = false;
		434	uint8_t BT_found = 0;
		435	i = 0;
		436
		437	set_BTOn();
		438
		439	lcd_cls();
		440	lcd_printp_at (0, 0, PSTR("BT initialisieren.."), 0);
		441	_delay_ms(200);
		442
		443	for (uint8_t z = (bt_name_length); z > 0; z--)
		444	{
		445	if (bt_name[z - 1] != ' ')
		446	{
		447	bt_name_len = z;
		448	break;
		449	}
		450	}
		451
		452	uart1_init(UART_BAUD_SELECT(57600, F_CPU));
		453	fifo_init(&in_fifo, bt_buffer, IN_FIFO_SIZE);
		454	_delay_ms(100);
		455	// debug_pgm(PSTR("bt_init"));
		456	uart_receive();
		457	// debug_pgm(PSTR("bt_init1"));
		458	fifo_clear(&in_fifo);
		459	send_cmd(BT_TEST, NULL);
		460	comm_mode = BT_NOECHO;
		461	send_cmd(BT_SET_ECHO, NULL);
		462	send_cmd(BT_SET_ANSWER, NULL);
		463
		464	// debug_pgm(PSTR("bt_init2"));
		465	#ifdef DEBUG
		466	debug_pgm(PSTR("Check with 57600"));
		467	#endif
		468	// send_cmd(BT_TEST, NULL); // Schrott löschen
		469
		470	if (send_cmd(BT_TEST, NULL)) // Test mit 57600
		471	{
		472	#ifdef DEBUG
		473	debug_pgm(PSTR("BT found 57600 Baud"));
		474	#endif
		475	BT_found = 1;
		476	}
		477
		478	if (BT_found == 0)
		479	{
		480	#ifdef DEBUG
		481	debug_pgm(PSTR("Check with 19200"));
		482	#endif
		483	uart1_init(UART_BAUD_SELECT(19200, F_CPU));// Test mit 19200
		484	_delay_ms(100);
		485	send_cmd(BT_TEST, NULL); // Schrott löschen
		486	send_cmd(BT_SET_ANSWER, NULL);
		487	send_cmd(BT_SET_ECHO, NULL);
		488
		489	if (send_cmd(BT_TEST, NULL))
		490	{
		491	debug_pgm(PSTR("19200 OK"));
		492	if (send_cmd(BT_TEST, NULL))
		493	{
		494	#ifdef DEBUG
		495	debug_pgm(PSTR("BT found 19200 Baud"));
		496	#endif
		497	BT_found = 2;
		498	}
		499	}
		500	}
		501
		502	if (BT_found == 0)
		503	{
		504	#ifdef DEBUG
		505	debug_pgm(PSTR("Check with 9600"));
		506	#endif
		507	uart1_init(UART_BAUD_SELECT(9600, F_CPU));//test mit 9600
		508	_delay_ms(100);
		509	send_cmd(BT_TEST, NULL);
		510	send_cmd(BT_SET_ANSWER, NULL);
		511	send_cmd(BT_SET_ECHO, NULL);
		512	if (send_cmd(BT_TEST, NULL));
		513	{
		514	#ifdef DEBUG
		515	debug_pgm(PSTR("9600 OK"));
		516	#endif
		517	if (send_cmd(BT_TEST, NULL))
		518	{
		519	#ifdef DEBUG
		520	debug_pgm(PSTR("BT found 9600 Baud"));
		521	#endif
		522	BT_found = 3;
		523	}
		524	}
		525	}
		526
		527	if (BT_found > 0)
		528	{
		529	/* Set comm_mode to CMD */
		530	comm_mode = BT_CMD;
		531	// test();
		532	/* Set BTM Baudrate */
		533	if (!(send_cmd(BT_SET_57600, NULL)))
		534	init_error = true;
		535	uart1_init(UART_BAUD_SELECT(57600, F_CPU));
		536	_delay_ms(100);
		537	// test();
		538	/* Clear remote address */
		539	if(!(send_cmd(BT_CLEAR_ADDRESS, NULL)))
		540	init_error = true;
		541	// test();
		542	/* Set BTM to SLAVE */
		543	if (!(send_cmd(BT_SET_SLAVE, NULL)))
		544	init_error = true;
		545	// test();
		546	/* Set BTM PIN */
		547	if(!(send_cmd(BT_SET_PIN, NULL)))
		548	init_error = true;
		549	// test();
		550	/* Set BTM Name */
		551	if(!(send_cmd(BT_SET_NAME, NULL)))
		552	init_error = true;
		553	_delay_ms(300);
		554	// test();
		555	if(!(send_cmd(BT_SET_DISPWRDOWN, NULL)))
		556	init_error = true;
		557	// test();
		558	/* Set BTM Echo aus */
		559	send_cmd(BT_SET_NOECHO, NULL);
		560	// test();
		561	comm_mode = BT_NOECHO;
		562	/* Set BTM Answer aus */
		563	send_cmd(BT_SET_NOANSWER, NULL);
		564	// test();
		565
		566	bt_mode = BLUETOOTH_SLAVE;
		567
		568	set_USBOn();
		569
		570	if (!init_error)
		571	{
		572	WriteBTInitFlag(); // Init merken
		573	return true;
		574	}
		575	else
		576	return false;
		577	}
		578	else
		579	{
		580	set_USBOn();
		581	return false;
		582	}
		583
		584	}
		585
		586
		587	#ifndef SaveMem
		588
		589	//--------------------------------------------------------------
		590	uint16_t bt_set_mode(const bt_mode_t mode)
		591	{
		592	if (update_comm_mode(0) == BT_DATA)
		593	return false;
		594
		595	if (mode == bt_mode)
		596	return true;
		597
		598	if (mode == BLUETOOTH_MASTER)
		599	if (send_cmd(BT_SET_MASTER, NULL))
		600	{
		601	bt_mode = BLUETOOTH_MASTER;
		602	test();
		603	send_cmd(BT_DISABLE_AUTOCONNECT, NULL);
		604	}
		605
		606	if (mode == BLUETOOTH_SLAVE)
		607	if (send_cmd(BT_SET_SLAVE, NULL))
		608	{
		609	bt_mode = BLUETOOTH_SLAVE;
		610	}
		611
		612	test();
		613	return mode == bt_mode;
		614	}
		615
		616
		617	//--------------------------------------------------------------
		618	uint16_t bt_receive(void *data, uint8_t length, uint16_t timeout_ms)
		619	{
		620	uint8_t rec_length = 0;
		621	uint8_t i = 0;
		622
		623	// while_timeout(true, timeout_ms);
		624	for(uint16_t __timeout = 0; __timeout++ <= true && (timeout_ms); _delay_ms(true ? 1 : 0))
		625	{
		626	if (i == length)
		627	return true;
		628
		629	uart_receive();
		630
		631	if (fifo_is_empty(&in_fifo))
		632	continue;
		633
		634	if (update_comm_mode(0) != BT_DATA)
		635	{
		636	#ifdef DEBUG
		637	debug_pgm(PSTR("not connected"));
		638	#endif
		639	return false;
		640	}
		641	// We have a connection
		642	if (timeout_ms == 0)
		643	timeout_ms += 2000;
		644
		645	if (fifo_is_empty(&in_fifo))
		646	continue;
		647
		648	// Find starting point of packet
		649	if (!rec_length)
		650	{
		651	fifo_read(&in_fifo, (char *)&rec_length);
		652
		653	if (rec_length != length)
		654	{
		655	rec_length = 0;
		656	}
		657	else
		658	{
		659	// You've got mail!
		660	timeout_ms += 2000;
		661	}
		662	}
		663	else
		664	{
		665	fifo_read(&in_fifo, (char *)data + i);
		666	i++;
		667	}
		668	}
		669	return false;
		670	}
		671
		672	#endif
		673
		674	#ifndef SaveMem
		675
		676
		677	//--------------------------------------------------------------
		678	uint16_t bt_send(void *data, const uint8_t length)
		679	{
		680	if (update_comm_mode(0) == BT_CMD)
		681	return false;
		682
		683	uart_send((const char *)&length, 1);
		684	uart_send((char *)data, length);
		685	return (update_comm_mode(0) == BT_DATA);
		686	}
		687
		688
		689	#ifdef SQUIRREL
		690
		691	//--------------------------------------------------------------
		692	uint16_t bt_connect(const char *address)
		693	{
		694	// Maybe we already disconnected???
		695	if (BT_DATA == update_comm_mode(0))
		696	{
		697	#ifdef DEBUG
		698	debug_pgm(PSTR("We are still connected..."));
		699	#endif
		700	return false;
		701	}
		702	test();
		703
		704	if (!send_cmd(BT_DISABLE_AUTOCONNECT, address))
		705	return false;
		706
		707	test();
		708	#ifdef DEBUG
		709	debug_pgm (PSTR ("SET_ADD"));
		710	#endif
		711
		712	if (!send_cmd(BT_SET_ADDRESS, address))
		713	return false;
		714
		715	test();
		716	#ifdef DEBUG
		717	debug_pgm (PSTR ("CONNECT"));
		718	#endif
		719
		720	if (!send_cmd(BT_CONNECT, NULL))
		721	return false;
		722	#ifdef DEBUG
		723	debug_pgm (PSTR ("WAIT FOR COMM"));
		724	#endif
		725	return (BT_DATA == update_comm_mode(60000));
		726	}
		727
		728
		729	//--------------------------------------------------------------
		730	uint16_t bt_disconnect(void)
		731	{
		732	/* Bluetooth reseten */
		733	// set_bit(PORTC.DIR, 4);
		734	// set_bit(PORTC.OUT, 4);
		735	_delay_ms(500);
		736	// clear_bit(PORTC.OUT, 4);
		737	// return bt_init();
		738
		739	#if 1
		740	if (BT_CMD == update_comm_mode(0))
		741	{
		742	fifo_clear(&in_fifo);
		743	return true;
		744	}
		745
		746	// Switch to online cmd mode
		747	for (uint8_t i = 0; i < 4; i++)
		748	{
		749	const char plus = '+';
		750	uart_send(&plus, 1);
		751	_delay_ms(1500);
		752	}
		753
		754	//comm_mode = BT_CMD;
		755
		756	if (!send_cmd(BT_DISCONNECT, NULL))
		757	return false;
		758
		759	test();
		760	if (!send_cmd(BT_CLEAR_ADDRESS, NULL))
		761	return false;
		762	test();
		763
		764	if (BT_CMD == update_comm_mode(10000))
		765	{
		766	fifo_clear(&in_fifo);
		767	return true;
		768	}
		769	#ifdef DEBUG
		770	debug_pgm(PSTR("Still in DATA??"));
		771	#endif
		772	return false;
		773	#endif
		774	}
		775
		776
		777	//--------------------------------------------------------------
		778	void copy_address(const char src, char dst)
		779	{
		780	uint8_t off = 0;
		781
		782	for (uint8_t i = 0; i < 14; i++)
		783	{
		784	if (src[i + off] == '-')
		785	off++;
		786
		787	dst[i] = src[i + off];
		788	}
		789	}
		790
		791
		792	//--------------------------------------------------------------
		793	uint16_t bt_discover(char result[8][12])
		794
		795	// 14.8.2011 ist noch nicht getestet, wird für PKT auch nicht benötigt, Cebra
		796	{
		797	// update_callback(20);
		798	test();
		799	if (!bt_set_mode(BLUETOOTH_MASTER))
		800	return false;
		801
		802	if (!send_cmd(BT_FIND_DEVICES, NULL))
		803	return false;
		804
		805	char buffer[255]; //oversized, but who cares?
		806	char *bufferhead = buffer;
		807	uint8_t pos = 0;
		808	uint16_t Timeout = 20000;
		809	uint8_t pos1 = 0;
		810
		811	do
		812	{
		813	uart_receive();
		814	Timeout--;
		815	pos1++;
		816	_delay_ms(1);
		817
		818	}
		819	while ((Timeout > 0) \|\|(!fifo_strstr_pgm(&in_fifo, PSTR("Inquiry Results:\r\n"))));
		820
		821	// byte_to_hex(Timeout);
		822
		823	assert_pgm((!fifo_strstr_pgm(&in_fifo, PSTR("Inquiry Results:\r\n"))),PSTR("INQ Result false"));
		824
		825	info_pgm (PSTR ("Rec1"));
		826
		827	for (uint16_t i = 0; i < 60000; i++)
		828	{
		829	//if ((i % 1000) == 0)
		830	//update_callback(40 + i / 1000);
		831	uart_receive();
		832	// lcd_printp(".", 0);
		833	_delay_ms(1);
		834	}
		835
		836	info_pgm (PSTR ("Rec2"));
		837
		838	//update_callback(100);
		839
		840	while (!fifo_is_empty(&in_fifo))
		841	{
		842	// Get next line
		843	while (!fifo_cmp_pgm(&in_fifo, PSTR("\r\n")))
		844	{
		845	fifo_read(&in_fifo, bufferhead);
		846	bufferhead++;
		847	}
		848	// terminate string
		849	*bufferhead = 0;
		850
		851	//reset bufferhead
		852	bufferhead = buffer;
		853
		854	if (strlen(buffer) == 0)
		855	continue; //the empty line before end of inquiry
		856
		857	if (strstr_P(buffer, PSTR("Inquiry End")))
		858	{
		859	fifo_clear(&in_fifo);
		860	test();
		861	return true;
		862	}
		863
		864	if (strncmp_P(PSTR("0012"), &buffer[21], 4))
		865	{
		866	copy_address(&buffer[21], result[pos]);
		867	pos++;
		868	}
		869	}
		870
		871	return false;
		872	}
		873
		874	#endif
		875	#endif
		876	#endif /* SQUIRREL */

Subversion Repositories Projects

(root)/Transportables_Koptertool/branch/GPL_PKT_V3_5_8b_FC086/bluetooth.c @ 2470 - Rev