1 //
2 // Copyright (c) 2010-2018 Antmicro
3 // Copyright (c) 2011-2015 Realtime Embedded
4 //
5 // This file is licensed under the MIT License.
6 // Full license text is available in 'licenses/MIT.txt'.
7 //
8 using System;
9 using NUnit.Framework;
10 using Antmicro.Renode.Core;
11 using Antmicro.Renode.Peripherals.I2C;
12 using System.Threading;
13 using System.Diagnostics;
14 using System.Collections.Generic;
15 
16 namespace Antmicro.Renode.PeripheralsTests
17 {
18     [TestFixture]
19     public class BMC050Test
20     {
21         [Test]
InitTest()22         public void InitTest()
23         {
24             List<byte> packet = new List<byte>();
25             var bmc050 = new BMC050();
26             bmc050.Reset();
27             // Check the Chip ID
28             packet.Add((byte)0xFC);
29             packet.Add((byte)0x00);
30             bmc050.Write(packet.ToArray());
31             packet.Clear();
32             byte[] chipId = bmc050.Read();
33             Assert.AreEqual(chipId[0], 0x3);
34             // Check the reserved 0x01 register
35             packet.Add((byte)0xFC);
36             packet.Add((byte)0x01);
37             bmc050.Write(packet.ToArray());
38             packet.Clear();
39             byte[] registerValue = bmc050.Read();
40             Assert.AreEqual(registerValue[0], 0x21);
41             // Check the bandwidth register
42             packet.Add((byte)0xFC);
43             packet.Add((byte)0x10);
44             bmc050.Write(packet.ToArray());
45             packet.Clear();
46             registerValue = bmc050.Read();
47             Assert.AreEqual(registerValue[0], 0x1F);
48             packet.Add((byte)0xFD);
49             packet.Add((byte)0x10);
50             packet.Add((byte)0x0C);
51             bmc050.Write(packet.ToArray());
52             packet.Clear();
53             packet.Add((byte)0xFC);
54             packet.Add((byte)0x10);
55             bmc050.Write(packet.ToArray());
56             packet.Clear();
57             registerValue = bmc050.Read();
58             Assert.AreEqual(registerValue[0], 0x0C);
59             // Check the power register
60             packet.Add((byte)0xFC);
61             packet.Add((byte)0x11);
62             bmc050.Write(packet.ToArray());
63             packet.Clear();
64             registerValue = bmc050.Read();
65             Assert.AreEqual(registerValue[0], 0x0);
66             packet.Add((byte)0xFD);
67             packet.Add((byte)0x11);
68             packet.Add((byte)0x07);
69             bmc050.Write(packet.ToArray());
70             packet.Clear();
71             packet.Add((byte)0xFC);
72             packet.Add((byte)0x11);
73             bmc050.Write(packet.ToArray());
74             packet.Clear();
75             registerValue = bmc050.Read();
76             Assert.AreEqual(registerValue[0], 0x07);
77             // Check the g-range register
78             packet.Add((byte)0xFC);
79             packet.Add((byte)0x0F);
80             bmc050.Write(packet.ToArray());
81             packet.Clear();
82             registerValue = bmc050.Read();
83             Assert.AreEqual(registerValue[0], 0x3);
84             // Check the SoftReset register value
85             // And funtionality through write of 0x5 to g-range register and check default value 0x3
86             packet.Add((byte)0xFC);
87             packet.Add((byte)0x14);
88             bmc050.Write(packet.ToArray());
89             packet.Clear();
90             registerValue = bmc050.Read();
91             Assert.AreEqual(registerValue[0], 0);
92             packet.Add((byte)0xFD);
93             packet.Add((byte)0x0F);
94             packet.Add((byte)0x05);
95             bmc050.Write(packet.ToArray());
96             packet.Clear();
97             packet.Add((byte)0xFC);
98             packet.Add((byte)0x0F);
99             bmc050.Write(packet.ToArray());
100             packet.Clear();
101             registerValue = bmc050.Read();
102             Assert.AreEqual(registerValue[0], 0x5);
103             packet.Add((byte)0xFD);
104             packet.Add((byte)0x14);
105             packet.Add((byte)0xB6); // Issue Soft Reset command
106             bmc050.Write(packet.ToArray());
107             packet.Clear();
108             packet.Add((byte)0xFC);
109             packet.Add((byte)0x0F);
110             bmc050.Write(packet.ToArray());
111             packet.Clear();
112             registerValue = bmc050.Read();
113             Assert.AreEqual(registerValue[0], 0x3);
114             // Check the DAQ control register
115             packet.Add((byte)0xFC);
116             packet.Add((byte)0x13);
117             bmc050.Write(packet.ToArray());
118             packet.Clear();
119             registerValue = bmc050.Read();
120             Assert.AreEqual(registerValue[0], 0x0);
121             packet.Add((byte)0xFD);
122             packet.Add((byte)0x13);
123             packet.Add((byte)0xC0);
124             bmc050.Write(packet.ToArray());
125             packet.Clear();
126             packet.Add((byte)0xFC);
127             packet.Add((byte)0x13);
128             bmc050.Write(packet.ToArray());
129             packet.Clear();
130             registerValue = bmc050.Read();
131             Assert.AreEqual(registerValue[0], 0xC0);
132             // Check the first IRQ control register
133             packet.Add((byte)0xFC);
134             packet.Add((byte)0x16);
135             bmc050.Write(packet.ToArray());
136             packet.Clear();
137             registerValue = bmc050.Read();
138             Assert.AreEqual(registerValue[0], 0x0);
139             packet.Add((byte)0xFD);
140             packet.Add((byte)0x16);
141             packet.Add((byte)0x21);
142             bmc050.Write(packet.ToArray());
143             packet.Clear();
144             packet.Add((byte)0xFC);
145             packet.Add((byte)0x16);
146             bmc050.Write(packet.ToArray());
147             packet.Clear();
148             registerValue = bmc050.Read();
149             Assert.AreEqual(registerValue[0], 0x21);
150             // Check the second IRQ control register
151             packet.Add((byte)0xFC);
152             packet.Add((byte)0x17);
153             bmc050.Write(packet.ToArray());
154             packet.Clear();
155             registerValue = bmc050.Read();
156             Assert.AreEqual(registerValue[0], 0x0);
157             packet.Add((byte)0xFD);
158             packet.Add((byte)0x17);
159             packet.Add((byte)0x01);
160             bmc050.Write(packet.ToArray());
161             packet.Clear();
162             packet.Add((byte)0xFC);
163             packet.Add((byte)0x17);
164             bmc050.Write(packet.ToArray());
165             packet.Clear();
166             registerValue = bmc050.Read();
167             Assert.AreEqual(registerValue[0], 0x01);
168             // Check the first IRQ mapping register
169             packet.Add((byte)0xFC);
170             packet.Add((byte)0x19);
171             bmc050.Write(packet.ToArray());
172             packet.Clear();
173             registerValue = bmc050.Read();
174             Assert.AreEqual(registerValue[0], 0x0);
175             packet.Add((byte)0xFD);
176             packet.Add((byte)0x19);
177             packet.Add((byte)0x02);
178             bmc050.Write(packet.ToArray());
179             packet.Clear();
180             packet.Add((byte)0xFC);
181             packet.Add((byte)0x19);
182             bmc050.Write(packet.ToArray());
183             packet.Clear();
184             registerValue = bmc050.Read();
185             Assert.AreEqual(registerValue[0], 0x02);
186             // Check the second IRQ mapping register
187             packet.Add((byte)0xFC);
188             packet.Add((byte)0x1A);
189             bmc050.Write(packet.ToArray());
190             packet.Clear();
191             registerValue = bmc050.Read();
192             Assert.AreEqual(registerValue[0], 0x0);
193             packet.Add((byte)0xFD);
194             packet.Add((byte)0x1A);
195             packet.Add((byte)0x01);
196             bmc050.Write(packet.ToArray());
197             packet.Clear();
198             packet.Add((byte)0xFC);
199             packet.Add((byte)0x1A);
200             bmc050.Write(packet.ToArray());
201             packet.Clear();
202             registerValue = bmc050.Read();
203             Assert.AreEqual(registerValue[0], 0x01);
204             // Check the third IRQ mapping register
205             packet.Add((byte)0xFC);
206             packet.Add((byte)0x1B);
207             bmc050.Write(packet.ToArray());
208             packet.Clear();
209             registerValue = bmc050.Read();
210             Assert.AreEqual(registerValue[0], 0x0);
211             packet.Add((byte)0xFD);
212             packet.Add((byte)0x1B);
213             packet.Add((byte)0x01);
214             bmc050.Write(packet.ToArray());
215             packet.Clear();
216             packet.Add((byte)0xFC);
217             packet.Add((byte)0x1B);
218             bmc050.Write(packet.ToArray());
219             packet.Clear();
220             registerValue = bmc050.Read();
221             Assert.AreEqual(registerValue[0], 0x01);
222             // Check the IRQ data source register
223             packet.Add((byte)0xFC);
224             packet.Add((byte)0x1E);
225             bmc050.Write(packet.ToArray());
226             packet.Clear();
227             registerValue = bmc050.Read();
228             Assert.AreEqual(registerValue[0], 0x0);
229             packet.Add((byte)0xFD);
230             packet.Add((byte)0x1E);
231             packet.Add((byte)0x04);
232             bmc050.Write(packet.ToArray());
233             packet.Clear();
234             packet.Add((byte)0xFC);
235             packet.Add((byte)0x1E);
236             bmc050.Write(packet.ToArray());
237             packet.Clear();
238             registerValue = bmc050.Read();
239             Assert.AreEqual(registerValue[0], 0x04);
240             // Check the IRQ electrical behaviour register
241             packet.Add((byte)0xFC);
242             packet.Add((byte)0x20);
243             bmc050.Write(packet.ToArray());
244             packet.Clear();
245             registerValue = bmc050.Read();
246             Assert.AreEqual(registerValue[0], 0x0);
247             packet.Add((byte)0xFD);
248             packet.Add((byte)0x20);
249             packet.Add((byte)0x01);
250             bmc050.Write(packet.ToArray());
251             packet.Clear();
252             packet.Add((byte)0xFC);
253             packet.Add((byte)0x20);
254             bmc050.Write(packet.ToArray());
255             packet.Clear();
256             registerValue = bmc050.Read();
257             Assert.AreEqual(registerValue[0], 0x01);
258             // Check the IRQ reset and mode register
259             packet.Add((byte)0xFC);
260             packet.Add((byte)0x21);
261             bmc050.Write(packet.ToArray());
262             packet.Clear();
263             registerValue = bmc050.Read();
264             Assert.AreEqual(registerValue[0], 0x0);
265             packet.Add((byte)0xFD);
266             packet.Add((byte)0x21);
267             packet.Add((byte)0x01);
268             bmc050.Write(packet.ToArray());
269             packet.Clear();
270             packet.Add((byte)0xFC);
271             packet.Add((byte)0x21);
272             bmc050.Write(packet.ToArray());
273             packet.Clear();
274             registerValue = bmc050.Read();
275             Assert.AreEqual(registerValue[0], 0x01);
276             // Check the LowDur register
277             packet.Add((byte)0xFC);
278             packet.Add((byte)0x22);
279             bmc050.Write(packet.ToArray());
280             packet.Clear();
281             registerValue = bmc050.Read();
282             Assert.AreEqual(registerValue[0], 0x09);
283             packet.Add((byte)0xFD);
284             packet.Add((byte)0x22);
285             packet.Add((byte)0x0D);
286             bmc050.Write(packet.ToArray());
287             packet.Clear();
288             packet.Add((byte)0xFC);
289             packet.Add((byte)0x22);
290             bmc050.Write(packet.ToArray());
291             packet.Clear();
292             registerValue = bmc050.Read();
293             Assert.AreEqual(registerValue[0], 0x0D);
294             // Check the LowTh register
295             packet.Add((byte)0xFC);
296             packet.Add((byte)0x23);
297             bmc050.Write(packet.ToArray());
298             packet.Clear();
299             registerValue = bmc050.Read();
300             Assert.AreEqual(registerValue[0], 0x30);
301             packet.Add((byte)0xFD);
302             packet.Add((byte)0x23);
303             packet.Add((byte)0x40);
304             bmc050.Write(packet.ToArray());
305             packet.Clear();
306             packet.Add((byte)0xFC);
307             packet.Add((byte)0x23);
308             bmc050.Write(packet.ToArray());
309             packet.Clear();
310             registerValue = bmc050.Read();
311             Assert.AreEqual(registerValue[0], 0x40);
312             // Check the low-g interrupt hysteresis register
313             packet.Add((byte)0xFC);
314             packet.Add((byte)0x24);
315             bmc050.Write(packet.ToArray());
316             packet.Clear();
317             registerValue = bmc050.Read();
318             Assert.AreEqual(registerValue[0], 0x81);
319             packet.Add((byte)0xFD);
320             packet.Add((byte)0x24);
321             packet.Add((byte)0x41);
322             bmc050.Write(packet.ToArray());
323             packet.Clear();
324             packet.Add((byte)0xFC);
325             packet.Add((byte)0x24);
326             bmc050.Write(packet.ToArray());
327             packet.Clear();
328             registerValue = bmc050.Read();
329             Assert.AreEqual(registerValue[0], 0x41);
330             // Check the HighDur register
331             packet.Add((byte)0xFC);
332             packet.Add((byte)0x25);
333             bmc050.Write(packet.ToArray());
334             packet.Clear();
335             registerValue = bmc050.Read();
336             Assert.AreEqual(registerValue[0], 0x0F);
337             packet.Add((byte)0xFD);
338             packet.Add((byte)0x25);
339             packet.Add((byte)0x1F);
340             bmc050.Write(packet.ToArray());
341             packet.Clear();
342             packet.Add((byte)0xFC);
343             packet.Add((byte)0x25);
344             bmc050.Write(packet.ToArray());
345             packet.Clear();
346             registerValue = bmc050.Read();
347             Assert.AreEqual(registerValue[0], 0x1F);
348             // Check the HighTh register
349             packet.Add((byte)0xFC);
350             packet.Add((byte)0x26);
351             bmc050.Write(packet.ToArray());
352             packet.Clear();
353             registerValue = bmc050.Read();
354             Assert.AreEqual(registerValue[0], 0xC0);
355             packet.Add((byte)0xFD);
356             packet.Add((byte)0x26);
357             packet.Add((byte)0xC1);
358             bmc050.Write(packet.ToArray());
359             packet.Clear();
360             packet.Add((byte)0xFC);
361             packet.Add((byte)0x26);
362             bmc050.Write(packet.ToArray());
363             packet.Clear();
364             registerValue = bmc050.Read();
365             Assert.AreEqual(registerValue[0], 0xC1);
366             // Check the SlopeDur register
367             packet.Add((byte)0xFC);
368             packet.Add((byte)0x27);
369             bmc050.Write(packet.ToArray());
370             packet.Clear();
371             registerValue = bmc050.Read();
372             Assert.AreEqual(registerValue[0], 0x0);
373             packet.Add((byte)0xFD);
374             packet.Add((byte)0x27);
375             packet.Add((byte)0x01);
376             bmc050.Write(packet.ToArray());
377             packet.Clear();
378             packet.Add((byte)0xFC);
379             packet.Add((byte)0x27);
380             bmc050.Write(packet.ToArray());
381             packet.Clear();
382             registerValue = bmc050.Read();
383             Assert.AreEqual(registerValue[0], 0x01);
384             // Check the SlopeTh register
385             packet.Add((byte)0xFC);
386             packet.Add((byte)0x28);
387             bmc050.Write(packet.ToArray());
388             packet.Clear();
389             registerValue = bmc050.Read();
390             Assert.AreEqual(registerValue[0], 0x14);
391             packet.Add((byte)0xFD);
392             packet.Add((byte)0x28);
393             packet.Add((byte)0x11);
394             bmc050.Write(packet.ToArray());
395             packet.Clear();
396             packet.Add((byte)0xFC);
397             packet.Add((byte)0x28);
398             bmc050.Write(packet.ToArray());
399             packet.Clear();
400             registerValue = bmc050.Read();
401             Assert.AreEqual(registerValue[0], 0x11);
402             // Check the first tap configuration register
403             packet.Add((byte)0xFC);
404             packet.Add((byte)0x2A);
405             bmc050.Write(packet.ToArray());
406             packet.Clear();
407             registerValue = bmc050.Read();
408             Assert.AreEqual(registerValue[0], 0x04);
409             packet.Add((byte)0xFD);
410             packet.Add((byte)0x2A);
411             packet.Add((byte)0x02);
412             bmc050.Write(packet.ToArray());
413             packet.Clear();
414             packet.Add((byte)0xFC);
415             packet.Add((byte)0x2A);
416             bmc050.Write(packet.ToArray());
417             packet.Clear();
418             registerValue = bmc050.Read();
419             Assert.AreEqual(registerValue[0], 0x02);
420             // Check the second tap configuration register
421             packet.Add((byte)0xFC);
422             packet.Add((byte)0x2B);
423             bmc050.Write(packet.ToArray());
424             packet.Clear();
425             registerValue = bmc050.Read();
426             Assert.AreEqual(registerValue[0], 0x0A);
427             packet.Add((byte)0xFD);
428             packet.Add((byte)0x2B);
429             packet.Add((byte)0x0C);
430             bmc050.Write(packet.ToArray());
431             packet.Clear();
432             packet.Add((byte)0xFC);
433             packet.Add((byte)0x2B);
434             bmc050.Write(packet.ToArray());
435             packet.Clear();
436             registerValue = bmc050.Read();
437             Assert.AreEqual(registerValue[0], 0x0C);
438             // Check the first orientation configuration register
439             packet.Add((byte)0xFC);
440             packet.Add((byte)0x2C);
441             bmc050.Write(packet.ToArray());
442             packet.Clear();
443             registerValue = bmc050.Read();
444             Assert.AreEqual(registerValue[0], 0x18);
445             packet.Add((byte)0xFD);
446             packet.Add((byte)0x2C);
447             packet.Add((byte)0x28);
448             bmc050.Write(packet.ToArray());
449             packet.Clear();
450             packet.Add((byte)0xFC);
451             packet.Add((byte)0x2C);
452             bmc050.Write(packet.ToArray());
453             packet.Clear();
454             registerValue = bmc050.Read();
455             Assert.AreEqual(registerValue[0], 0x28);
456             // Check the second orientation configuration register
457             packet.Add((byte)0xFC);
458             packet.Add((byte)0x2D);
459             bmc050.Write(packet.ToArray());
460             packet.Clear();
461             registerValue = bmc050.Read();
462             Assert.AreEqual(registerValue[0], 0x08);
463             packet.Add((byte)0xFD);
464             packet.Add((byte)0x2D);
465             packet.Add((byte)0x04);
466             bmc050.Write(packet.ToArray());
467             packet.Clear();
468             packet.Add((byte)0xFC);
469             packet.Add((byte)0x2D);
470             bmc050.Write(packet.ToArray());
471             packet.Clear();
472             registerValue = bmc050.Read();
473             Assert.AreEqual(registerValue[0], 0x04);
474             // Check the first flat angle configuration register
475             packet.Add((byte)0xFC);
476             packet.Add((byte)0x2E);
477             bmc050.Write(packet.ToArray());
478             packet.Clear();
479             registerValue = bmc050.Read();
480             Assert.AreEqual(registerValue[0], 0x08);
481             packet.Add((byte)0xFD);
482             packet.Add((byte)0x2E);
483             packet.Add((byte)0x10);
484             bmc050.Write(packet.ToArray());
485             packet.Clear();
486             packet.Add((byte)0xFC);
487             packet.Add((byte)0x2E);
488             bmc050.Write(packet.ToArray());
489             packet.Clear();
490             registerValue = bmc050.Read();
491             Assert.AreEqual(registerValue[0], 0x10);
492             // Check the second flat configuration register
493             packet.Add((byte)0xFC);
494             packet.Add((byte)0x2F);
495             bmc050.Write(packet.ToArray());
496             packet.Clear();
497             registerValue = bmc050.Read();
498             Assert.AreEqual(registerValue[0], 0x10);
499             packet.Add((byte)0xFD);
500             packet.Add((byte)0x2F);
501             packet.Add((byte)0x20);
502             bmc050.Write(packet.ToArray());
503             packet.Clear();
504             packet.Add((byte)0xFC);
505             packet.Add((byte)0x2F);
506             bmc050.Write(packet.ToArray());
507             packet.Clear();
508             registerValue = bmc050.Read();
509             Assert.AreEqual(registerValue[0], 0x20);
510             // Check the self test register
511             packet.Add((byte)0xFC);
512             packet.Add((byte)0x32);
513             bmc050.Write(packet.ToArray());
514             packet.Clear();
515             registerValue = bmc050.Read();
516             Assert.AreEqual(registerValue[0], 0x70);
517             packet.Add((byte)0xFD);
518             packet.Add((byte)0x32);
519             packet.Add((byte)0x75);
520             bmc050.Write(packet.ToArray());
521             packet.Clear();
522             packet.Add((byte)0xFC);
523             packet.Add((byte)0x32);
524             bmc050.Write(packet.ToArray());
525             packet.Clear();
526             registerValue = bmc050.Read();
527             Assert.AreEqual(registerValue[0], 0x75);
528             // Check the EEPROM control register
529             packet.Add((byte)0xFC);
530             packet.Add((byte)0x33);
531             bmc050.Write(packet.ToArray());
532             packet.Clear();
533             registerValue = bmc050.Read();
534             Assert.AreEqual(registerValue[0], 0x04);
535             packet.Add((byte)0xFD);
536             packet.Add((byte)0x33);
537             packet.Add((byte)0x41); // Unlocks the EEPROM
538             bmc050.Write(packet.ToArray());
539             packet.Clear();
540             packet.Add((byte)0xFC);
541             packet.Add((byte)0x33);
542             bmc050.Write(packet.ToArray());
543             packet.Clear();
544             registerValue = bmc050.Read();
545             Assert.AreEqual(registerValue[0], 0x41);
546             // Check the interface config register
547             packet.Add((byte)0xFC);
548             packet.Add((byte)0x34);
549             bmc050.Write(packet.ToArray());
550             packet.Clear();
551             registerValue = bmc050.Read();
552             Assert.AreEqual(registerValue[0], 0x0);
553             packet.Add((byte)0xFD);
554             packet.Add((byte)0x34);
555             packet.Add((byte)0x02);
556             bmc050.Write(packet.ToArray());
557             packet.Clear();
558             packet.Add((byte)0xFC);
559             packet.Add((byte)0x34);
560             bmc050.Write(packet.ToArray());
561             packet.Clear();
562             registerValue = bmc050.Read();
563             Assert.AreEqual(registerValue[0], 0x02);
564             // Check the offset compensation register
565             // Setting bit 7 resets the value of the register
566             packet.Add((byte)0xFC);
567             packet.Add((byte)0x36);
568             bmc050.Write(packet.ToArray());
569             packet.Clear();
570             registerValue = bmc050.Read();
571             Assert.AreEqual(registerValue[0], 0x0);
572             packet.Add((byte)0xFD);
573             packet.Add((byte)0x36);
574             packet.Add((byte)0x02);
575             bmc050.Write(packet.ToArray());
576             packet.Clear();
577             packet.Add((byte)0xFC);
578             packet.Add((byte)0x36);
579             bmc050.Write(packet.ToArray());
580             packet.Clear();
581             registerValue = bmc050.Read();
582             Assert.AreEqual(registerValue[0], 0x02);
583             packet.Add((byte)0xFD);
584             packet.Add((byte)0x36);
585             packet.Add((byte)0x80);
586             bmc050.Write(packet.ToArray());
587             packet.Clear();
588             packet.Add((byte)0xFC);
589             packet.Add((byte)0x36);
590             bmc050.Write(packet.ToArray());
591             packet.Clear();
592             registerValue = bmc050.Read();
593             Assert.AreEqual(registerValue[0], 0x0);
594             // Check the offset target register
595             packet.Add((byte)0xFC);
596             packet.Add((byte)0x37);
597             bmc050.Write(packet.ToArray());
598             packet.Clear();
599             registerValue = bmc050.Read();
600             Assert.AreEqual(registerValue[0], 0x0);
601             packet.Add((byte)0xFD);
602             packet.Add((byte)0x37);
603             packet.Add((byte)0x01);
604             bmc050.Write(packet.ToArray());
605             packet.Clear();
606             packet.Add((byte)0xFC);
607             packet.Add((byte)0x37);
608             bmc050.Write(packet.ToArray());
609             packet.Clear();
610             registerValue = bmc050.Read();
611             Assert.AreEqual(registerValue[0], 0x01);
612             // Check the offset compensation for filtered x axis data register
613             packet.Add((byte)0xFC);
614             packet.Add((byte)0x38);
615             bmc050.Write(packet.ToArray());
616             packet.Clear();
617             registerValue = bmc050.Read();
618             Assert.AreEqual(registerValue[0], 0x0);
619             packet.Add((byte)0xFD);
620             packet.Add((byte)0x38);
621             packet.Add((byte)0x01);
622             bmc050.Write(packet.ToArray());
623             packet.Clear();
624             packet.Add((byte)0xFC);
625             packet.Add((byte)0x38);
626             bmc050.Write(packet.ToArray());
627             packet.Clear();
628             registerValue = bmc050.Read();
629             Assert.AreEqual(registerValue[0], 0x01);
630             // Check the offset compensation for filtered y axis data register
631             packet.Add((byte)0xFC);
632             packet.Add((byte)0x39);
633             bmc050.Write(packet.ToArray());
634             packet.Clear();
635             registerValue = bmc050.Read();
636             Assert.AreEqual(registerValue[0], 0x0);
637             packet.Add((byte)0xFD);
638             packet.Add((byte)0x39);
639             packet.Add((byte)0x01);
640             bmc050.Write(packet.ToArray());
641             packet.Clear();
642             packet.Add((byte)0xFC);
643             packet.Add((byte)0x39);
644             bmc050.Write(packet.ToArray());
645             packet.Clear();
646             registerValue = bmc050.Read();
647             Assert.AreEqual(registerValue[0], 0x01);
648             // Check the offset compensation for filtered z axis data register
649             packet.Add((byte)0xFC);
650             packet.Add((byte)0x3A);
651             bmc050.Write(packet.ToArray());
652             packet.Clear();
653             registerValue = bmc050.Read();
654             Assert.AreEqual(registerValue[0], 0x0);
655             packet.Add((byte)0xFD);
656             packet.Add((byte)0x3A);
657             packet.Add((byte)0x01);
658             bmc050.Write(packet.ToArray());
659             packet.Clear();
660             packet.Add((byte)0xFC);
661             packet.Add((byte)0x3A);
662             bmc050.Write(packet.ToArray());
663             packet.Clear();
664             registerValue = bmc050.Read();
665             Assert.AreEqual(registerValue[0], 0x01);
666             // Check the offset compensation for unfiltered x axis data register
667             packet.Add((byte)0xFC);
668             packet.Add((byte)0x3B);
669             bmc050.Write(packet.ToArray());
670             packet.Clear();
671             registerValue = bmc050.Read();
672             Assert.AreEqual(registerValue[0], 0x0);
673             packet.Add((byte)0xFD);
674             packet.Add((byte)0x3B);
675             packet.Add((byte)0x01);
676             bmc050.Write(packet.ToArray());
677             packet.Clear();
678             packet.Add((byte)0xFC);
679             packet.Add((byte)0x3B);
680             bmc050.Write(packet.ToArray());
681             packet.Clear();
682             registerValue = bmc050.Read();
683             Assert.AreEqual(registerValue[0], 0x01);
684             // Check the offset compensation for unfiltered y axis data register
685             packet.Add((byte)0xFC);
686             packet.Add((byte)0x3C);
687             bmc050.Write(packet.ToArray());
688             packet.Clear();
689             registerValue = bmc050.Read();
690             Assert.AreEqual(registerValue[0], 0x0);
691             packet.Add((byte)0xFD);
692             packet.Add((byte)0x3C);
693             packet.Add((byte)0x01);
694             bmc050.Write(packet.ToArray());
695             packet.Clear();
696             packet.Add((byte)0xFC);
697             packet.Add((byte)0x3C);
698             bmc050.Write(packet.ToArray());
699             packet.Clear();
700             registerValue = bmc050.Read();
701             Assert.AreEqual(registerValue[0], 0x01);
702             // Check the offset compensation for unfiltered z axis data register
703             packet.Add((byte)0xFC);
704             packet.Add((byte)0x3D);
705             bmc050.Write(packet.ToArray());
706             packet.Clear();
707             registerValue = bmc050.Read();
708             Assert.AreEqual(registerValue[0], 0x0);
709             packet.Add((byte)0xFD);
710             packet.Add((byte)0x3D);
711             packet.Add((byte)0x01);
712             bmc050.Write(packet.ToArray());
713             packet.Clear();
714             packet.Add((byte)0xFC);
715             packet.Add((byte)0x3D);
716             bmc050.Write(packet.ToArray());
717             packet.Clear();
718             registerValue = bmc050.Read();
719             Assert.AreEqual(registerValue[0], 0x01);
720             // Check the Magnetometer Chip ID
721             packet.Add((byte)0xFC);
722             packet.Add((byte)0x40);
723             bmc050.Write(packet.ToArray());
724             packet.Clear();
725             registerValue = bmc050.Read();
726             Assert.AreEqual(registerValue[0], 0x32);
727             // Check the magnetometer interrupt status register
728             packet.Add((byte)0xFC);
729             packet.Add((byte)0x4A);
730             bmc050.Write(packet.ToArray());
731             packet.Clear();
732             registerValue = bmc050.Read();
733             Assert.AreEqual(registerValue[0], 0x0);
734             // Check the magnetometer control register
735             packet.Add((byte)0xFC);
736             packet.Add((byte)0x4B);
737             bmc050.Write(packet.ToArray());
738             packet.Clear();
739             registerValue = bmc050.Read();
740             Assert.AreEqual(registerValue[0], 0x1);
741             packet.Add((byte)0xFD);
742             packet.Add((byte)0x4B);
743             packet.Add((byte)0x0);
744             bmc050.Write(packet.ToArray());
745             packet.Clear();
746             packet.Add((byte)0xFC);
747             packet.Add((byte)0x4B);
748             bmc050.Write(packet.ToArray());
749             packet.Clear();
750             registerValue = bmc050.Read();
751             Assert.AreEqual(registerValue[0], 0x0);
752             // Do not leave it in suspended state
753             packet.Add((byte)0xFD);
754             packet.Add((byte)0x4B);
755             packet.Add((byte)0x01);
756             bmc050.Write(packet.ToArray());
757             packet.Clear();
758             packet.Add((byte)0xFC);
759             packet.Add((byte)0x4B);
760             bmc050.Write(packet.ToArray());
761             packet.Clear();
762             registerValue = bmc050.Read();
763             Assert.AreEqual(registerValue[0], 0x01);
764             // Check the magnetometer operation mode register
765             packet.Add((byte)0xFC);
766             packet.Add((byte)0x4C);
767             bmc050.Write(packet.ToArray());
768             packet.Clear();
769             registerValue = bmc050.Read();
770             Assert.AreEqual(registerValue[0], 0x06);
771             packet.Add((byte)0xFD);
772             packet.Add((byte)0x4C);
773             packet.Add((byte)0x07);
774             bmc050.Write(packet.ToArray());
775             packet.Clear();
776             packet.Add((byte)0xFC);
777             packet.Add((byte)0x4C);
778             bmc050.Write(packet.ToArray());
779             packet.Clear();
780             registerValue = bmc050.Read();
781             Assert.AreEqual(registerValue[0], 0x07);
782             // Check the first magnetometer interrupt ctrl register
783             packet.Add((byte)0xFC);
784             packet.Add((byte)0x4D);
785             bmc050.Write(packet.ToArray());
786             packet.Clear();
787             registerValue = bmc050.Read();
788             Assert.AreEqual(registerValue[0], 0x3F);
789             packet.Add((byte)0xFD);
790             packet.Add((byte)0x4D);
791             packet.Add((byte)0x38);
792             bmc050.Write(packet.ToArray());
793             packet.Clear();
794             packet.Add((byte)0xFC);
795             packet.Add((byte)0x4D);
796             bmc050.Write(packet.ToArray());
797             packet.Clear();
798             registerValue = bmc050.Read();
799             Assert.AreEqual(registerValue[0], 0x38);
800             // Check the second magnetometer interrupt ctrl register
801             packet.Add((byte)0xFC);
802             packet.Add((byte)0x4E);
803             bmc050.Write(packet.ToArray());
804             packet.Clear();
805             registerValue = bmc050.Read();
806             Assert.AreEqual(registerValue[0], 0x07);
807             packet.Add((byte)0xFD);
808             packet.Add((byte)0x4E);
809             packet.Add((byte)0x05);
810             bmc050.Write(packet.ToArray());
811             packet.Clear();
812             packet.Add((byte)0xFC);
813             packet.Add((byte)0x4E);
814             bmc050.Write(packet.ToArray());
815             packet.Clear();
816             registerValue = bmc050.Read();
817             Assert.AreEqual(registerValue[0], 0x05);
818             // Check the magnetometer LowTh register
819             packet.Add((byte)0xFC);
820             packet.Add((byte)0x4F);
821             bmc050.Write(packet.ToArray());
822             packet.Clear();
823             registerValue = bmc050.Read();
824             Assert.AreEqual(registerValue[0], 0x0);
825             packet.Add((byte)0xFD);
826             packet.Add((byte)0x4F);
827             packet.Add((byte)0x01);
828             bmc050.Write(packet.ToArray());
829             packet.Clear();
830             packet.Add((byte)0xFC);
831             packet.Add((byte)0x4F);
832             bmc050.Write(packet.ToArray());
833             packet.Clear();
834             registerValue = bmc050.Read();
835             Assert.AreEqual(registerValue[0], 0x01);
836             // Check the magnetometer HighTh register
837             packet.Add((byte)0xFC);
838             packet.Add((byte)0x50);
839             bmc050.Write(packet.ToArray());
840             packet.Clear();
841             registerValue = bmc050.Read();
842             Assert.AreEqual(registerValue[0], 0x0);
843             packet.Add((byte)0xFD);
844             packet.Add((byte)0x50);
845             packet.Add((byte)0x01);
846             bmc050.Write(packet.ToArray());
847             packet.Clear();
848             packet.Add((byte)0xFC);
849             packet.Add((byte)0x50);
850             bmc050.Write(packet.ToArray());
851             packet.Clear();
852             registerValue = bmc050.Read();
853             Assert.AreEqual(registerValue[0], 0x01);
854             // Check the magnetometer RepXY register
855             packet.Add((byte)0xFC);
856             packet.Add((byte)0x51);
857             bmc050.Write(packet.ToArray());
858             packet.Clear();
859             registerValue = bmc050.Read();
860             Assert.AreEqual(registerValue[0], 0x0);
861             packet.Add((byte)0xFD);
862             packet.Add((byte)0x51);
863             packet.Add((byte)0x01);
864             bmc050.Write(packet.ToArray());
865             packet.Clear();
866             packet.Add((byte)0xFC);
867             packet.Add((byte)0x51);
868             bmc050.Write(packet.ToArray());
869             packet.Clear();
870             registerValue = bmc050.Read();
871             Assert.AreEqual(registerValue[0], 0x01);
872             // Check the magnetometer RepZ register
873             packet.Add((byte)0xFC);
874             packet.Add((byte)0x52);
875             bmc050.Write(packet.ToArray());
876             packet.Clear();
877             registerValue = bmc050.Read();
878             Assert.AreEqual(registerValue[0], 0x0);
879             packet.Add((byte)0xFD);
880             packet.Add((byte)0x52);
881             packet.Add((byte)0x01);
882             bmc050.Write(packet.ToArray());
883             packet.Clear();
884             packet.Add((byte)0xFC);
885             packet.Add((byte)0x52);
886             bmc050.Write(packet.ToArray());
887             packet.Clear();
888             registerValue = bmc050.Read();
889             Assert.AreEqual(registerValue[0], 0x01);
890         }
891 
892         [Test]
ReadDataTest()893         public void ReadDataTest()
894         {
895             List<byte> packet = new List<byte>();
896             var bmc050 = new BMC050();
897             bmc050.Reset();
898 
899             // TODO : setup device? With parameters for measurements
900             for(int i = 0; i < 5; i++)
901             {
902                 // Read temperature measurement
903                 // Construct packet list for read of temperature register
904                 packet.Add((byte)0xFC);
905                 packet.Add((byte)0x08);
906                 bmc050.Write(packet.ToArray());
907                 packet.Clear();
908                 // Read Temperature register
909                 byte[] temperature = bmc050.Read();
910                 Assert.Greater(temperature[0], 0);
911                 ////////////////////////////////////////////////////////////
912                 // Read Accelerometer X measurement
913                 // Construct packet list for read of accelerometer X register
914                 packet.Add((byte)0xFC);
915                 packet.Add((byte)0x02);
916                 bmc050.Write(packet.ToArray());
917                 packet.Clear();
918                 // Read Accelerometer X LSB and MSB registers
919                 byte[] acc_x = bmc050.Read();
920                 int accelerometerX = (((int)acc_x[1] << 2) & 0xFFC) + (((int)acc_x[0] >> 6) & 0x3);
921                 Assert.Greater(accelerometerX, 0);
922                 // Read Accelerometer Y measurement
923                 // Construct packet list for read of accelerometer Y register
924                 packet.Add((byte)0xFC);
925                 packet.Add((byte)0x04);
926                 bmc050.Write(packet.ToArray());
927                 packet.Clear();
928                 // Read Accelerometer Y LSB and MSB registers
929                 byte[] acc_y = bmc050.Read();
930                 int accelerometerY = (((int)acc_y[1] << 2) & 0xFFC) + (((int)acc_y[0] >> 6) & 0x3);
931                 Assert.Greater(accelerometerY, 0);
932                 // Read Accelerometer Z measurement
933                 // Construct packet list for read of accelerometer Z register
934                 packet.Add((byte)0xFC);
935                 packet.Add((byte)0x06);
936                 bmc050.Write(packet.ToArray());
937                 packet.Clear();
938                 // Read Accelerometer Z LSB and MSB registers
939                 byte[] acc_z = bmc050.Read();
940                 int accelerometerZ = (((int)acc_z[1] << 2) & 0xFFC) + (((int)acc_z[0] >> 6) & 0x3);
941                 Assert.Greater(accelerometerZ, 0);
942                 ////////////////////////////////////////////////////////////
943                 // Read Magnetometer X measurement
944                 // Construct packet list for read of magnetometer X register
945                 packet.Add((byte)0xFC);
946                 packet.Add((byte)0x42);
947                 bmc050.Write(packet.ToArray());
948                 packet.Clear();
949                 // Read Magnetometer X LSB and MSB registers
950                 byte[] mag_x = bmc050.Read();
951                 int magnetometerX = (UInt16)((((UInt16)mag_x[1] << 5) & 0x1FE0) + (((UInt16)mag_x[0] >> 3) & 0x1F));
952                 Assert.Greater(magnetometerX, 0);
953                 // Read Magnetometer Y measurement
954                 // Construct packet list for read of magnetometer Y register
955                 packet.Add((byte)0xFC);
956                 packet.Add((byte)0x44);
957                 bmc050.Write(packet.ToArray());
958                 packet.Clear();
959                 // Read Magnetometer Y LSB and MSB registers
960                 byte[] mag_y = bmc050.Read();
961                 int magnetometerY = (UInt16)((((UInt16)mag_y[1] << 5) & 0x1FE0) + (((UInt16)mag_y[0] >> 3) & 0x1F));
962                 Assert.Greater(magnetometerY, 0);
963                 // Read Magnetometer Z measurement
964                 // Construct packet list for read of magnetometer Z register
965                 packet.Add((byte)0xFC);
966                 packet.Add((byte)0x46);
967                 bmc050.Write(packet.ToArray());
968                 packet.Clear();
969                 // Read Magnetometer Z LSB and MSB registers
970                 byte[] mag_z = bmc050.Read();
971                 int magnetometerZ = (UInt16)((((UInt16)mag_z[1] << 5) & 0x1FE0) + (((UInt16)mag_z[0] >> 3) & 0x1F));
972                 Assert.Greater(magnetometerZ, 0);
973                 // Read Hall resistance measurement
974                 // Construct packet list for read of Hall resistance registers
975                 packet.Add((byte)0xFC);
976                 packet.Add((byte)0x48);
977                 bmc050.Write(packet.ToArray());
978                 packet.Clear();
979                 // Read Hall resistance LSB and MSB registers
980                 byte[] rhall = bmc050.Read();
981                 int resistanceHall = (UInt16)((((UInt16)rhall[1] << 5) & 0x1FE0) + (((UInt16)rhall[0] >> 3) & 0x1F));
982                 Assert.Greater(resistanceHall, 0);
983                 ////////////////////////////////////////////////////////////
984                 // Test read of all three accelerometer ADC values in one go
985                 packet.Add((byte)0xFC);
986                 packet.Add((byte)0x02);
987                 bmc050.Write(packet.ToArray());
988                 packet.Clear();
989                 // Read
990                 byte[] acc_data = bmc050.Read();
991                 accelerometerX = (((int)acc_data[1] << 2) & 0xFFC) + (((int)acc_data[0] >> 6) & 0x3);
992                 Assert.Greater(accelerometerX, 0);
993                 accelerometerY = (((int)acc_data[3] << 2) & 0xFFC) + (((int)acc_data[2] >> 6) & 0x3);
994                 Assert.Greater(accelerometerY, 0);
995                 accelerometerZ = (((int)acc_data[5] << 2) & 0xFFC) + (((int)acc_data[4] >> 6) & 0x3);
996                 Assert.Greater(accelerometerZ, 0);
997                 ////////////////////////////////////////////////////////////
998                 // Test read of all three magnetometer ADC and Hall resistance values in one go
999                 // Construct packet list for read of magnetometer X register
1000                 packet.Add((byte)0xFC);
1001                 packet.Add((byte)0x42);
1002                 bmc050.Write(packet.ToArray());
1003                 packet.Clear();
1004                 // Read
1005                 byte[] mag_data = bmc050.Read();
1006                 magnetometerX = (UInt16)((((UInt16)mag_data[1] << 5) & 0x1FE0) + (((UInt16)mag_data[0] >> 3) & 0x1F));
1007                 Assert.Greater(magnetometerX, 0);
1008                 magnetometerY = (UInt16)((((UInt16)mag_data[3] << 5) & 0x1FE0) + (((UInt16)mag_data[2] >> 3) & 0x1F));
1009                 Assert.Greater(magnetometerY, 0);
1010                 magnetometerZ = (UInt16)((((UInt16)mag_data[5] << 5) & 0x1FE0) + (((UInt16)mag_data[4] >> 3) & 0x1F));
1011                 Assert.Greater(magnetometerZ, 0);
1012                 resistanceHall = (UInt16)((((UInt16)mag_data[7] << 5) & 0x1FE0) + (((UInt16)mag_data[6] >> 3) & 0x1F));
1013                 Assert.Greater(resistanceHall, 0);
1014             }
1015         }
1016     }
1017 }
1018 
1019