Dariaceli's Git
Browse code

Use strutils instead of snprintf (to save some bytes), set default year to 2014, partial revamp of the stopwatch

Dario Rodriguez authored on 14/01/2014 22:59:59
Showing 1 changed files
metawatch/bt_l2cap.c
History View file @ 940a301
... ... 
@@ -7,6 +7,7 @@
7 7 
 #include "bt_hci.h"
8 8 
 #include "bt_l2cap.h"
9 9
10 
+#include "strutils.h"
10 11 
 #include "oswald_main.h"
11 12
12 13 
 static bt_l2cap_con_t _l2cap_con;
... ... 
@@ -84,11 +85,13 @@ void bt_l2cap_proc_signalling(const uint16_t handle, unsigned char *mdat, uint16
84 85 
 			uint16_t src_CID = mdat[6] | (mdat[7] << 8);;
85 86
86 87 
 #if defined MW_DEVBOARD_V2
87 
-			debug_uart_tx("connection request on ");
88 
-			snprintf(tstr, 16, "PSM 0x%04x ", PSM);
88 
+			debug_uart_tx("connection request on PSM 0x");
89 
+			hexnum2str(PSM,tstr,4);
89 90 
 			debug_uart_tx(tstr);
90 
-			snprintf(tstr, 16, "srcCID 0x%04x\n", src_CID);
91 
+			debug_uart_tx(" srcCID 0x");
92 
+			hexnum2str(PSM,src_CID,4);
91 93 
 			debug_uart_tx(tstr);
94 
+			debug_uart_tx("\n");
92 95 
 #endif
93 96 
 			bt_l2cap_handle_connection_request(handle, ident, PSM, src_CID);
94 97 
 			} break;
... ... 
@@ -103,17 +106,22 @@ void bt_l2cap_proc_signalling(const uint16_t handle, unsigned char *mdat, uint16
103 106 
 			bt_l2cap_conf_resp_t resp;
104 107
105 108 
 #if defined MW_DEVBOARD_V2
106 
-			debug_uart_tx("configure request ");
107 
-			snprintf(tstr, 16, "len 0x%04x ", len);
109 
+			debug_uart_tx("configure request len 0x");
110 
+			hexnum2str(len,tstr,4);
108 111 
 			debug_uart_tx(tstr);
109 
-			snprintf(tstr, 16, "DCID 0x%04x ", dst_CID);
112 
+			debug_uart_tx(" DCID 0x");
113 
+			hexnum2str(dst_CID,tstr,4);
110 114 
 			debug_uart_tx(tstr);
111 
-			snprintf(tstr, 16, "flags 0x%04x\n", flags);
115 
+			debug_uart_tx(" flags 0x");
116 
+			hexnum2str(flags,tstr,4);
112 117 
 			debug_uart_tx(tstr);
118 
+			debug_uart_tx("\n");
113 119 
 #if 0
114 120 
 			for (i=8; i<((len-4)+8); i++) {
115 
-				snprintf(tstr, 16, "0x%02x ", mdat[i]);
121 
+				debug_uart_tx("0x");
122 
+				hexnum2str(mdat[i],tstr,2);
116 123 
 				debug_uart_tx(tstr);
124 
+				debug_uart_tx(" ");
117 125 
 			}
118 126 
 			debug_uart_tx("\n");
119 127 
 #endif
Browse code

Maybe a little sniff mode, add ambient light adc (not working), fix accelerometer display orientation

Nils Faerber authored on 06/05/2013 23:39:18
Showing 1 changed files
metawatch/bt_l2cap.c
History View file @ 3e320aa
... ... 
@@ -224,7 +224,8 @@ void bt_l2cap_handle_connection_request(const uint16_t handle, const uint8_t ide
224 224 
 {
225 225 
 	bt_l2cap_conn_resp_t resp;
226 226
227 
-	if (_l2cap_con.cstate == BT_L2CAP_CON_IDLE) {
227 
+	// for now we only support one connection, only on PSM 0x1001
228 
+	if (_l2cap_con.cstate == BT_L2CAP_CON_IDLE && PSM == 0x1001) {
228 229 
 		bt_l2cap_conf_req_t req;
229 230
230 231 
 		_l2cap_con.cstate = BT_L2CAP_CON_CONNECTED;
... ... 
@@ -258,6 +259,12 @@ void bt_l2cap_handle_connection_request(const uint16_t handle, const uint8_t ide
258 259 
 		req.odat = _l2cap_con.locMTU;
259 260
260 261 
 		bt_acl_send(handle, PB_FIRST_FLUSHABLE, BC_NO_BROADCAST, L2CAP_CID_SIGNALING, sizeof(bt_l2cap_conf_req_t), &req);
262 
+
263 
+		// max_interval Mandatory Range: 0x0006 to 0x0540
264 
+		// min_interval Mandatory Range: 0x0006 to 0x0540
265 
+		// sniff_attempt Mandatory Range for Controller: 1 to Tsniff/2
266 
+		// sniff_timeout Mandatory Range for Controller: 0 to 0x0028
267 
+		bt_hci_set_sniff_mode(handle, 0x10, 0x06, 0x20, 0x10);
261 268 
 	} else {
262 269 
 		resp.resp = CONNECTION_RESPONSE;
263 270 
 		resp.ident = ident;
Browse code

Here we are! MetaWatch support in Oswald!

Nils Faerber authored on 27/04/2013 20:22:32
Showing 1 changed files
metawatch/bt_l2cap.c
History View file @ 1553c23
1 1 
new file mode 100644
... ... 
@@ -0,0 +1,274 @@
1 
+#include <stdint.h>
2 
+#include <stdio.h>
3 
+#include <string.h>
4 
+
5 
+#include "mw_uart.h"
6 
+#include "mw_bt.h"
7 
+#include "bt_hci.h"
8 
+#include "bt_l2cap.h"
9 
+
10 
+#include "oswald_main.h"
11 
+
12 
+static bt_l2cap_con_t _l2cap_con;
13 
+
14 
+void init_l2cap(void)
15 
+{
16 
+	memset(&_l2cap_con, 0, sizeof(bt_l2cap_con_t));
17 
+}
18 
+
19 
+void bt_l2cap_proc_dyn_channel(const uint16_t channel, const uint16_t handle, const void *mdat, uint16_t mlen)
20 
+{
21 
+	if (channel == _l2cap_con.locCID) {
22 
+		debug_uart_tx("L2CAP data rcvd: ");
23 
+		debug_dump_ascii(mlen, mdat);
24 
+		if (_l2cap_con.PSM == 0x1001) {
25 
+			oswald_handle_comm_input(mlen, mdat);
26 
+		} else if (_l2cap_con.PSM == 0x0001) { // SDP
27 
+			debug_uart_tx("SDP req: ");
28 
+			debug_dump_hex(mlen, mdat);
29 
+		} else
30 
+			debug_uart_tx("L2CAP data on unhandled PSM\n");
31 
+	} else {
32 
+		debug_uart_tx("L2CAP CID does not match local CID\n");
33 
+	}
34 
+}
35 
+
36 
+uint8_t bt_l2cap_get_connected(const uint16_t channel)
37 
+{
38 
+	if (_l2cap_con.locCID == channel)
39 
+		return _l2cap_con.cstate;
40 
+	else
41 
+		return BT_L2CAP_CON_IDLE;
42 
+}
43 
+
44 
+void bt_l2cap_send_channel(const uint16_t channel, const void *mdat, uint16_t mlen)
45 
+{
46 
+	if (_l2cap_con.cstate == BT_L2CAP_CON_CONNECTED && _l2cap_con.hci_handle != 0 && _l2cap_con.remCID != 0 &&
47 
+		mlen != 0 && mdat != NULL) {
48 
+		bt_acl_send(_l2cap_con.hci_handle, PB_FIRST_FLUSHABLE, BC_NO_BROADCAST, _l2cap_con.remCID, mlen, mdat);
49 
+	}
50 
+}
51 
+
52 
+typedef struct {
53 
+	uint8_t resp;
54 
+	uint8_t ident;
55 
+	uint16_t length;
56 
+	uint16_t DCID;
57 
+	uint16_t SCID;
58 
+} __attribute__((packed)) bt_l2cap_disconn_resp_t;
59 
+
60 
+typedef struct {
61 
+	uint8_t resp;
62 
+	uint8_t ident;
63 
+	uint16_t length;
64 
+	uint16_t SCID;
65 
+	uint16_t flags;
66 
+	uint16_t result;
67 
+	uint16_t config;
68 
+} __attribute__((packed)) bt_l2cap_conf_resp_t;
69 
+
70 
+
71 
+void bt_l2cap_proc_signalling(const uint16_t handle, unsigned char *mdat, uint16_t mlen)
72 
+{
73 
+#if defined MW_DEVBOARD_V2
74 
+	char tstr[16];
75 
+#endif
76 
+	debug_uart_tx("ACL L2CAP signalling ");
77 
+	switch (mdat[0]) {
78 
+		case COMMAND_REJECT:
79 
+			debug_uart_tx("command reject\n");
80 
+			break;
81 
+		case CONNECTION_REQUEST: {
82 
+			uint8_t ident = mdat[1];
83 
+			uint16_t PSM = mdat[4] | (mdat[5] << 8);;
84 
+			uint16_t src_CID = mdat[6] | (mdat[7] << 8);;
85 
+
86 
+#if defined MW_DEVBOARD_V2
87 
+			debug_uart_tx("connection request on ");
88 
+			snprintf(tstr, 16, "PSM 0x%04x ", PSM);
89 
+			debug_uart_tx(tstr);
90 
+			snprintf(tstr, 16, "srcCID 0x%04x\n", src_CID);
91 
+			debug_uart_tx(tstr);
92 
+#endif
93 
+			bt_l2cap_handle_connection_request(handle, ident, PSM, src_CID);
94 
+			} break;
95 
+		case CONNECTION_RESPONSE:
96 
+			debug_uart_tx("connection response\n");
97 
+			break;
98 
+		case CONFIGURE_REQUEST: {
99 
+			uint8_t ident = mdat[1];
100 
+			uint16_t len = mdat[2] | (mdat[3] << 8);
101 
+			uint16_t dst_CID = mdat[4] | (mdat[5] << 8);
102 
+			uint16_t flags = mdat[6] | (mdat[7] << 8);
103 
+			bt_l2cap_conf_resp_t resp;
104 
+
105 
+#if defined MW_DEVBOARD_V2
106 
+			debug_uart_tx("configure request ");
107 
+			snprintf(tstr, 16, "len 0x%04x ", len);
108 
+			debug_uart_tx(tstr);
109 
+			snprintf(tstr, 16, "DCID 0x%04x ", dst_CID);
110 
+			debug_uart_tx(tstr);
111 
+			snprintf(tstr, 16, "flags 0x%04x\n", flags);
112 
+			debug_uart_tx(tstr);
113 
+#if 0
114 
+			for (i=8; i<((len-4)+8); i++) {
115 
+				snprintf(tstr, 16, "0x%02x ", mdat[i]);
116 
+				debug_uart_tx(tstr);
117 
+			}
118 
+			debug_uart_tx("\n");
119 
+#endif
120 
+			debug_dump_hex(len-4+8, (mdat+8));
121 
+#endif
122 
+			resp.resp = CONFIGURE_RESPONSE;
123 
+			resp.ident = ident;
124 
+			resp.length = 0x06;
125 
+			if (dst_CID != _l2cap_con.locCID)
126 
+				debug_uart_tx("warning: DCID does not match\n");
127 
+			resp.SCID = _l2cap_con.remCID;
128 
+			resp.flags = flags;
129 
+			resp.result = 0x0000; // success
130 
+			resp.config = 0x0000; // OK?
131 
+
132 
+			bt_acl_send(handle, PB_FIRST_FLUSHABLE, BC_NO_BROADCAST, L2CAP_CID_SIGNALING, sizeof(bt_l2cap_conf_resp_t)-2, &resp);
133 
+
134 
+			} break;
135 
+		case CONFIGURE_RESPONSE:
136 
+			debug_uart_tx("configure response\n");
137 
+			break;
138 
+		case DISCONNECTION_REQUEST: {
139 
+			bt_l2cap_disconn_resp_t resp;
140 
+			uint8_t ident = mdat[1];
141 
+			uint16_t dst_CID = mdat[4] | (mdat[5] << 8);
142 
+			uint16_t src_CID = mdat[6] | (mdat[7] << 8);
143 
+
144 
+			debug_uart_tx("disconnect request\n");
145 
+
146 
+			if (dst_CID != _l2cap_con.locCID || src_CID != _l2cap_con.remCID)
147 
+				debug_uart_tx("warning: discon on unknown CID\n");
148 
+			resp.resp = DISCONNECTION_RESPONSE;
149 
+			resp.ident = ident;
150 
+			resp.length = 0x0004;
151 
+			resp.DCID = _l2cap_con.locCID;
152 
+			resp.SCID = _l2cap_con.remCID;
153 
+
154 
+			bt_acl_send(handle, PB_FIRST_FLUSHABLE, BC_NO_BROADCAST, L2CAP_CID_SIGNALING, sizeof(bt_l2cap_disconn_resp_t), &resp);
155 
+
156 
+			init_l2cap();
157 
+			} break;
158 
+		case DISCONNECTION_RESPONSE:
159 
+			debug_uart_tx("disconnect response\n");
160 
+			break;
161 
+    		case ECHO_REQUEST:
162 
+			debug_uart_tx("echo request\n");
163 
+			mdat[0] = ECHO_RESPONSE;
164 
+			bt_acl_send(handle, PB_FIRST_FLUSHABLE, BC_NO_BROADCAST, L2CAP_CID_SIGNALING, mlen, mdat);
165 
+			break;
166 
+		case ECHO_RESPONSE:
167 
+			debug_uart_tx("echo response\n");
168 
+			break;
169 
+		case INFORMATION_REQUEST: {
170 
+			uint16_t info_type = mdat[4] | (mdat[5] << 8);
171 
+			debug_uart_tx("information request ");
172 
+			switch (info_type) {
173 
+				case 0x0001:
174 
+					debug_uart_tx("connectionless mtu\n");
175 
+					break;
176 
+				case 0x0002:
177 
+					debug_uart_tx("ext. feat. support\n");
178 
+					mdat[0] = INFORMATION_RESPONSE;
179 
+					mdat[2] = 0x02;
180 
+					mdat[3] = 0x00;
181 
+					mdat[6] = 0x01; // not supported
182 
+					mdat[7] = 0x00;
183 
+					bt_acl_send(handle, PB_FIRST_FLUSHABLE, BC_NO_BROADCAST, L2CAP_CID_SIGNALING, 0x08, mdat);
184 
+					break;
185 
+				case 0x0003:
186 
+					debug_uart_tx("fixed channel support\n");
187 
+					break;
188 
+				default:
189 
+					debug_uart_tx("unknown\n");
190 
+					break;
191 
+			};
192 
+			} break;
193 
+		case INFORMATION_RESPONSE:
194 
+			debug_uart_tx("information response\n");
195 
+			break;
196 
+		default:
197 
+			debug_uart_tx("unknown\n");
198 
+			break;
199 
+	}
200 
+}
201 
+
202 
+typedef struct {
203 
+	uint8_t resp;
204 
+	uint8_t ident;
205 
+	uint16_t length;
206 
+	uint16_t DCID;
207 
+	uint16_t SCID;
208 
+	uint16_t result;
209 
+	uint16_t status;
210 
+} __attribute__((packed)) bt_l2cap_conn_resp_t;
211 
+
212 
+typedef struct {
213 
+	uint8_t resp;
214 
+	uint8_t ident;
215 
+	uint16_t length;
216 
+	uint16_t DCID;
217 
+	uint16_t flags;
218 
+	uint8_t option;
219 
+	uint8_t olen;
220 
+	uint16_t odat;
221 
+} __attribute__((packed)) bt_l2cap_conf_req_t;
222 
+
223 
+void bt_l2cap_handle_connection_request(const uint16_t handle, const uint8_t ident, const uint16_t PSM, const uint16_t src_CID)
224 
+{
225 
+	bt_l2cap_conn_resp_t resp;
226 
+
227 
+	if (_l2cap_con.cstate == BT_L2CAP_CON_IDLE) {
228 
+		bt_l2cap_conf_req_t req;
229 
+
230 
+		_l2cap_con.cstate = BT_L2CAP_CON_CONNECTED;
231 
+		_l2cap_con.hci_handle = handle;
232 
+		_l2cap_con.PSM = PSM;
233 
+
234 
+		_l2cap_con.locCID = 0x0040;
235 
+		_l2cap_con.remCID = src_CID;
236 
+
237 
+		_l2cap_con.locMTU = 0xf0;
238 
+		_l2cap_con.remMTU = 0x00;
239 
+
240 
+		resp.resp = CONNECTION_RESPONSE;
241 
+		resp.ident = ident;
242 
+		resp.length = 0x0008;
243 
+		resp.DCID = _l2cap_con.locCID;
244 
+		resp.SCID = _l2cap_con.remCID;
245 
+		resp.result = BT_L2CAP_CON_RES_SUCCESS;
246 
+		resp.status = BT_L2CAP_CON_STAT_NOINFO;
247 
+
248 
+		debug_uart_tx("l2cap accepting connection\n");
249 
+		bt_acl_send(handle, PB_FIRST_FLUSHABLE, BC_NO_BROADCAST, L2CAP_CID_SIGNALING, sizeof(bt_l2cap_conn_resp_t), &resp);
250 
+
251 
+		req.resp = CONFIGURE_REQUEST;
252 
+		req.ident = ident;
253 
+		req.length = 0x08;
254 
+		req.DCID = _l2cap_con.remCID;
255 
+		req.flags = 0x00;
256 
+		req.option = 0x01; // MTU
257 
+		req.olen = 0x02;
258 
+		req.odat = _l2cap_con.locMTU;
259 
+
260 
+		bt_acl_send(handle, PB_FIRST_FLUSHABLE, BC_NO_BROADCAST, L2CAP_CID_SIGNALING, sizeof(bt_l2cap_conf_req_t), &req);
261 
+	} else {
262 
+		resp.resp = CONNECTION_RESPONSE;
263 
+		resp.ident = ident;
264 
+		resp.length = 0x0008;
265 
+		resp.DCID = 0x0000;
266 
+		resp.SCID = src_CID;
267 
+		resp.result = BT_L2CAP_CON_RES_REFUSED_RSRC;
268 
+		resp.status = BT_L2CAP_CON_STAT_NOINFO;
269 
+
270 
+		debug_uart_tx("l2cap refusing connection\n");
271 
+		bt_acl_send(handle, PB_FIRST_FLUSHABLE, BC_NO_BROADCAST, L2CAP_CID_SIGNALING, sizeof(bt_l2cap_conn_resp_t), &resp);
272 
+	}
273 
+}
274 
+