[硅谷行报名]“脑电之翼”--牛刀小试（专注度点亮LDE）

照海倚天

    话说申请了机智云gokit2开发板，咱就不能闲着啊 ，就要干活 ，就把最近的进度汇报下。

    因为项目的需要，就在网上购买了“意念方舟头带”，下面是他的自拍，好家伙小400块，不是特别贵吧，但是还是感觉有点贵，想想是学校给的项目经费，掏的是学校的腰包就不那么心疼了，但是国家支持咱们研究，咱就得好好干活啊，你说对吧，闲话少叙，开工。

                        

    通过这一段时间的学习与实践，已经可以从“意念方舟头带”上获取数据，并进行处理分析，并在读取数据后做出相应动作，下面是具体说明。

    硬件模块：Thinkgear模块  机智云GoKit2    蓝牙HC-05模块

    软件：  MindViewer   XCOM V2.0.exe   arduino

    细节说明：之前一直再采集数据，但是数据一直不能正常读取到，后来通过与卖家的交流与沟通发现可能是头带上蓝牙模块的问题，经过改装最后终于解决了其中的问题，最后能从头带上获取数据了。

     

    数据通过蓝牙传输，其中只要把蓝牙模块配置为主机，波特率设置为57600

    接线方式如图

   

           实物图：

           

         至于头带吗 当然是要戴在头上的，因为本人忒丑，就让这个歪果仁来展示怎么佩戴吧 。

         

    原始数据：

     

    经过查阅thinkgear数据手册可以知道：TGAM大约每秒钟发送513个包， 发送送的包有小包和大包两种：小包的格式是AA AA 04 80 02 xxHigh xxLow xxCheckSum前面的AA AA 04 80 02 是不变的，后三个字节是一只变化的，xxHigh和xxLow组成了原始数据rawdata，xxCheckSum就是校验和。所以一个小包里面只包含了一个对开发者来 说有用的数据，那就是rawdata，可以说一个小包就是一个原始数据，大约每秒钟会有 512个原始数据。

rawdata = (xxHigh << 8) | xxLow;

if(rawdata > 32768)

{   

     rawdata  =65536;

}

现在原始数据就这么算出来了，但是在算原始数据之前，我们先应该检查校验和。

sum = ((0x80 + 0x02 + xxHigh + xxLow)^ 0xFFFFFFFF) & 0xFF

    就是把04后面的四个字节加起来，取反，再取低八位。 如果算出来的sum和xxCheckSum是相等的，那说明这个包是正确的，然后再去计算 rawdata，否则直接忽略这个包。丢包率在10%以下是不会对最后结果造成影响的。

大包中是信号强度Signal,专注度Attention,放松度 Meditation,和8个EEG Power的值它们在在第513个这个大包里面，这个大包的格式是固定的。

AA 同步

AA 同步

20 是十进制的32，即有32个字节的payload，除掉20本身+两个AA同步+最后校验和

02 代表信号值Signal

33信号的值

83 代表EEG Power开始了

18 是十进制的24，说明EEG Power是由24个字节组成的，以下每三个字节为一组

0D Delta 1/3

CC Delta 2/3

64Delta 3/3

01 Theta 1/3

81 Theta 2/3

C5 Theta 3/3

01 LowAlpha 1/3

30 LowAlpha 2/3

36 LowAlpha 3/3

00 HighAlpha 1/3

BD HighAlpha 2/3

E4 HighAlpha 3/3

00 LowBeta 1/3

A9LowBeta 2/3

F0 LowBeta 3/3

00 Hi**eta 1/3

F4 Hi**eta 2/3

66 Hi**eta 3/3

00 LowGamma 1/3

FF LowGamma 2/3

F0 LowGamma 3/3

00 MiddleGamma 1/3

DB MiddleGamma 2/3

FB MiddleGamma 3/3

04 代表专注度Attention

00 Attention的值(0到100之间)

05 代表放松度Meditation

00 Meditation的值(0到100之间) D5 校验和

所得的数据可以在MindViewer中显示出来，其中包括attention，Meditation等数据 及最原始的α，β，γ等波形 。

效果如图所示

通过对数据的识别与处理，我使用机智云提够的Gokit2开发板，对数据进行处理，计划做成专注度识别控制的LED显示。

下面为arduino源程序 ：

1. <em>#define LED 13
   
2. 
   
3. #define BAUDRATE 57600
   
4. 
   
5. #define DEBUGOUTPUT 0
   
6. 
   
7. #define GREENLED1 3
   
8. 
   
9. #define GREENLED2 4
   
10. 
    
11. #define GREENLED3 5
    
12. 
    
13. #define YELLOWLED1 6
    
14. 
    
15. #define YELLOWLED2 7
    
16. 
    
17. #define YELLOWLED3 8
    
18. 
    
19. #define YELLOWLED4 9
    
20. 
    
21. #define REDLED1 10
    
22. 
    
23. #define REDLED2 11
    
24. 
    
25. #define REDLED3 12
    
26. 
    
27. #define powercontrol 10
    
28. 
    
29. // checksum variables
    
30. 
    
31. byte generatedChecksum = 0;
    
32. 
    
33. byte checksum = 0;
    
34. 
    
35. int payloadLength = 0;
    
36. 
    
37. byte payloadData[64] = {0};
    
38. 
    
39. byte poorQuality = 0;
    
40. 
    
41. byte attention = 0;
    
42. 
    
43. byte meditation = 0;
    
44. 
    
45. // system variables
    
46. 
    
47. long lastReceivedPacket = 0;
    
48. 
    
49. boolean bigPacket = false;
    
50. 
    
51. 
    
52. 
    
53. void setup()
    
54. 
    
55. {
    
56. 
    
57. pinMode(GREENLED1, OUTPUT);
    
58. 
    
59. pinMode(GREENLED2, OUTPUT);
    
60. 
    
61. pinMode(GREENLED3, OUTPUT);
    
62. 
    
63. pinMode(YELLOWLED1, OUTPUT);
    
64. 
    
65. pinMode(YELLOWLED2, OUTPUT);
    
66. 
    
67. pinMode(YELLOWLED3, OUTPUT);
    
68. 
    
69. pinMode(YELLOWLED4, OUTPUT);
    
70. 
    
71. pinMode(REDLED1, OUTPUT);
    
72. 
    
73. pinMode(REDLED2, OUTPUT);
    
74. 
    
75. pinMode(REDLED3, OUTPUT);
    
76. 
    
77. pinMode(LED, OUTPUT);
    
78. 
    
79. Serial.begin(BAUDRATE); // USB
    
80. 
    
81. }
    
82. 
    
83. 
    
84. 
    
85. byte ReadOneByte()
    
86. 
    
87. {
    
88. 
    
89. int ByteRead;
    
90. 
    
91. while(!Serial.available());
    
92. 
    
93. ByteRead = Serial.read();
    
94. 
    
95. #if DEBUGOUTPUT
    
96. 
    
97. Serial.print((char)ByteRead);
    
98. 
    
99. #endif
    
100. 
     
101. return ByteRead;
     
102. 
     
103. }
     
104. 
     
105. 
     
106. 
     
107. void loop()
     
108. 
     
109. {
     
110. 
     
111. // Look for sync bytes
     
112. 
     
113. if(ReadOneByte() == 170)
     
114. 
     
115. {
     
116. 
     
117. if(ReadOneByte() == 170)
     
118. 
     
119. {
     
120. 
     
121. payloadLength = ReadOneByte();
     
122. 
     
123. if(payloadLength > 169) //Payload lengthcan not be greater than 169
     
124. 
     
125. return;
     
126. 
     
127. generatedChecksum = 0;
     
128. 
     
129. for(int i = 0; i < payloadLength; i++)
     
130. 
     
131. {
     
132. 
     
133. payloadData = ReadOneByte(); //Readpayload into memory
     
134. 
     
135. generatedChecksum += payloadData;
     
136. 
     
137. }
     
138. 
     
139. checksum = ReadOneByte(); //Read checksumbyte from stream
     
140. 
     
141. generatedChecksum = 255 -generatedChecksum; //Take one's compliment of generated checksum
     
142. 
     
143. if(checksum == generatedChecksum)
     
144. 
     
145. {
     
146. 
     
147. poorQuality = 200;
     
148. 
     
149. attention = 0;
     
150. 
     
151. meditation = 0;
     
152. 
     
153. for(int i = 0; i < payloadLength; i++)
     
154. 
     
155. { // Parse the payload
     
156. 
     
157. switch (payloadData)
     
158. 
     
159. {
     
160. 
     
161. case 2:
     
162. 
     
163. i++;
     
164. 
     
165. poorQuality = payloadData;
     
166. 
     
167. bigPacket = true;
     
168. 
     
169. break;
     
170. 
     
171. case 4:
     
172. 
     
173. i++;
     
174. 
     
175. attention = payloadData;
     
176. 
     
177. break;
     
178. 
     
179. case 5:
     
180. 
     
181. i++;
     
182. 
     
183. meditation = payloadData;
     
184. 
     
185. break;
     
186. 
     
187. case 0x80:
     
188. 
     
189. i = i + 3;
     
190. 
     
191. break;
     
192. 
     
193. case 0x83:
     
194. 
     
195. i = i + 25;
     
196. 
     
197. break;
     
198. 
     
199. default:
     
200. 
     
201. break;
     
202. 
     
203. } // switch
     
204. 
     
205. } // for loop
     
206. 
     
207. #if !DEBUGOUTPUT
     
208. 
     
209. if(bigPacket)
     
210. 
     
211. {
     
212. 
     
213. if(poorQuality == 0)
     
214. 
     
215. digitalWrite(LED, HIGH);
     
216. 
     
217. else
     
218. 
     
219. digitalWrite(LED, LOW);
     
220. 
     
221. Serial.print("PoorQuality: ");
     
222. 
     
223. Serial.print(poorQuality, DEC);
     
224. 
     
225. Serial.print(" Attention: ");
     
226. 
     
227. Serial.print(attention, DEC);
     
228. 
     
229. Serial.print(" Time since last packet:");
     
230. 
     
231. Serial.print(millis() - lastReceivedPacket,DEC);
     
232. 
     
233. lastReceivedPacket = millis();
     
234. 
     
235. Serial.print("\n");
     
236. 
     
237. switch(attention / 10)
     
238. 
     
239. {
     
240. 
     
241. case 0:
     
242. 
     
243. digitalWrite(GREENLED1, HIGH);
     
244. 
     
245. digitalWrite(GREENLED2, LOW);
     
246. 
     
247. digitalWrite(GREENLED3, LOW);
     
248. 
     
249. digitalWrite(YELLOWLED1, LOW);
     
250. 
     
251. digitalWrite(YELLOWLED2, LOW);
     
252. 
     
253. digitalWrite(YELLOWLED3, LOW);
     
254. 
     
255. digitalWrite(YELLOWLED4, LOW);
     
256. 
     
257. digitalWrite(REDLED1, LOW);
     
258. 
     
259. digitalWrite(REDLED2, LOW);
     
260. 
     
261. digitalWrite(REDLED3, LOW);
     
262. 
     
263. break;
     
264. 
     
265. case 1:
     
266. 
     
267. digitalWrite(GREENLED1, HIGH);
     
268. 
     
269. digitalWrite(GREENLED2, HIGH);
     
270. 
     
271. digitalWrite(GREENLED3, LOW);
     
272. 
     
273. digitalWrite(YELLOWLED1, LOW);
     
274. 
     
275. digitalWrite(YELLOWLED2, LOW);
     
276. 
     
277. digitalWrite(YELLOWLED3, LOW);
     
278. 
     
279. digitalWrite(YELLOWLED4, LOW);
     
280. 
     
281. digitalWrite(REDLED1, LOW);
     
282. 
     
283. digitalWrite(REDLED2, LOW);
     
284. 
     
285. digitalWrite(REDLED3, LOW);
     
286. 
     
287. break;
     
288. 
     
289. case 2:
     
290. 
     
291. digitalWrite(GREENLED1, HIGH);
     
292. 
     
293. digitalWrite(GREENLED2, HIGH);
     
294. 
     
295. digitalWrite(GREENLED3, HIGH);
     
296. 
     
297. digitalWrite(YELLOWLED1, LOW);
     
298. 
     
299. digitalWrite(YELLOWLED2, LOW);
     
300. 
     
301. digitalWrite(YELLOWLED3, LOW);
     
302. 
     
303. digitalWrite(YELLOWLED4, LOW);
     
304. 
     
305. digitalWrite(REDLED1, LOW);
     
306. 
     
307. digitalWrite(REDLED2, LOW);
     
308. 
     
309. digitalWrite(REDLED3, LOW);
     
310. 
     
311. break;
     
312. 
     
313. case 3:
     
314. 
     
315. digitalWrite(GREENLED1, HIGH);
     
316. 
     
317. digitalWrite(GREENLED2, HIGH);
     
318. 
     
319. digitalWrite(GREENLED3, HIGH);
     
320. 
     
321. digitalWrite(YELLOWLED1, HIGH);
     
322. 
     
323. digitalWrite(YELLOWLED2, LOW);
     
324. 
     
325. digitalWrite(YELLOWLED3, LOW);
     
326. 
     
327. digitalWrite(YELLOWLED4, LOW);
     
328. 
     
329. digitalWrite(REDLED1, LOW);
     
330. 
     
331. digitalWrite(REDLED2, LOW);
     
332. 
     
333. digitalWrite(REDLED3, LOW);
     
334. 
     
335. break;
     
336. 
     
337. case 4:
     
338. 
     
339. digitalWrite(GREENLED1, HIGH);
     
340. 
     
341. digitalWrite(GREENLED2, HIGH);
     
342. 
     
343. digitalWrite(GREENLED3, HIGH);
     
344. 
     
345. digitalWrite(YELLOWLED1, HIGH);
     
346. 
     
347. digitalWrite(YELLOWLED2, HIGH);
     
348. 
     
349. digitalWrite(YELLOWLED3, LOW);
     
350. 
     
351. digitalWrite(YELLOWLED4, LOW);
     
352. 
     
353. digitalWrite(REDLED1, LOW);
     
354. 
     
355. digitalWrite(REDLED2, LOW);
     
356. 
     
357. digitalWrite(REDLED3, LOW);
     
358. 
     
359. break;
     
360. 
     
361. case 5:
     
362. 
     
363. digitalWrite(GREENLED1, HIGH);
     
364. 
     
365. digitalWrite(GREENLED2, HIGH);
     
366. 
     
367. digitalWrite(GREENLED3, HIGH);
     
368. 
     
369. digitalWrite(YELLOWLED1, HIGH);
     
370. 
     
371. digitalWrite(YELLOWLED2, HIGH);
     
372. 
     
373. digitalWrite(YELLOWLED3, HIGH);
     
374. 
     
375. digitalWrite(YELLOWLED4, LOW);
     
376. 
     
377. digitalWrite(REDLED1, LOW);
     
378. 
     
379. digitalWrite(REDLED2, LOW);
     
380. 
     
381. digitalWrite(REDLED3, LOW);
     
382. 
     
383. break;
     
384. 
     
385. case 6:
     
386. 
     
387. digitalWrite(GREENLED1, HIGH);
     
388. 
     
389. digitalWrite(GREENLED2, HIGH);
     
390. 
     
391. digitalWrite(GREENLED3, HIGH);
     
392. 
     
393. digitalWrite(YELLOWLED1, HIGH);
     
394. 
     
395. digitalWrite(YELLOWLED2, HIGH);
     
396. 
     
397. digitalWrite(YELLOWLED3, HIGH);
     
398. 
     
399. digitalWrite(YELLOWLED4, HIGH);
     
400. 
     
401. digitalWrite(REDLED1, LOW);
     
402. 
     
403. digitalWrite(REDLED2, LOW);
     
404. 
     
405. digitalWrite(REDLED3, LOW);
     
406. 
     
407. break;
     
408. 
     
409. case 7:
     
410. 
     
411. digitalWrite(GREENLED1, HIGH);
     
412. 
     
413. digitalWrite(GREENLED2, HIGH);
     
414. 
     
415. digitalWrite(GREENLED3, HIGH);
     
416. 
     
417. digitalWrite(YELLOWLED1, HIGH);
     
418. 
     
419. digitalWrite(YELLOWLED2, HIGH);
     
420. 
     
421. digitalWrite(YELLOWLED3, HIGH);
     
422. 
     
423. digitalWrite(YELLOWLED4, HIGH);
     
424. 
     
425. digitalWrite(REDLED1, HIGH);
     
426. 
     
427. digitalWrite(REDLED2, LOW);
     
428. 
     
429. digitalWrite(REDLED3, LOW);
     
430. 
     
431. break;
     
432. 
     
433. case 8:
     
434. 
     
435. digitalWrite(GREENLED1, HIGH);
     
436. 
     
437. digitalWrite(GREENLED2, HIGH);
     
438. 
     
439. digitalWrite(GREENLED3, HIGH);
     
440. 
     
441. digitalWrite(YELLOWLED1, HIGH);
     
442. 
     
443. digitalWrite(YELLOWLED2, HIGH);
     
444. 
     
445. digitalWrite(YELLOWLED3, HIGH);
     
446. 
     
447. digitalWrite(YELLOWLED4, HIGH);
     
448. 
     
449. digitalWrite(REDLED1, HIGH);
     
450. 
     
451. digitalWrite(REDLED2, HIGH);
     
452. 
     
453. digitalWrite(REDLED3, LOW);
     
454. 
     
455. break;
     
456. 
     
457. case 9:
     
458. 
     
459. digitalWrite(GREENLED1, HIGH);
     
460. 
     
461. digitalWrite(GREENLED2, HIGH);
     
462. 
     
463. digitalWrite(GREENLED3, HIGH);
     
464. 
     
465. digitalWrite(YELLOWLED1, HIGH);
     
466. 
     
467. digitalWrite(YELLOWLED2, HIGH);
     
468. 
     
469. digitalWrite(YELLOWLED3, HIGH);
     
470. 
     
471. digitalWrite(YELLOWLED4, HIGH);
     
472. 
     
473. digitalWrite(REDLED1, HIGH);
     
474. 
     
475. digitalWrite(REDLED2, HIGH);
     
476. 
     
477. digitalWrite(REDLED3, HIGH);
     
478. 
     
479. break;
     
480. 
     
481. case 10:
     
482. 
     
483. digitalWrite(GREENLED1, HIGH);
     
484. 
     
485. digitalWrite(GREENLED2, HIGH);
     
486. 
     
487. digitalWrite(GREENLED3, HIGH);
     
488. 
     
489. digitalWrite(YELLOWLED1, HIGH);
     
490. 
     
491. digitalWrite(YELLOWLED2, HIGH);
     
492. 
     
493. digitalWrite(YELLOWLED3, HIGH);
     
494. 
     
495. digitalWrite(YELLOWLED4, HIGH);
     
496. 
     
497. digitalWrite(REDLED1, HIGH);
     
498. 
     
499. digitalWrite(REDLED2, HIGH);
     
500. 
     
501. digitalWrite(REDLED3, HIGH);
     
502. 
     
503. break;
     
504. 
     
505. }
     
506. 
     
507. }
     
508. 
     
509. #endif
     
510. 
     
511. bigPacket = false;
     
512. 
     
513. }
     
514. 
     
515. else {
     
516. 
     
517. // Checksum Error
     
518. 
     
519. } // end if else for checksum
     
520. 
     
521. } // end if read 0xAA byte
     
522. 
     
523. } // end if read 0xAA byte
     
524. 
     
525. }</em>

复制代码

程序可实现通过把人的专注度以点亮LED多少展示出来 。

     这个是视频展示的地址 ：   http://v.youku.com/v_show/id_XMTgzMTY0NjI2OA==.html

    未来计划：

    进一步研究数据，对数据进一步分析处理，深入研究thinkgear数据流，分析每一种波形的相应功能作用，提取关于健康方面有用信息，贴近脑点之翼的初衷，自己设计自己的app进行数据分析处理，尽可能的完成最初的设计理念。

bigfanofloT

赞一个

Cherry

期待楼主佳作