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 SHT21Test
20     {
21         [Test]
InitTest()22         public void InitTest()
23         {
24             List<byte> packet = new List<byte>();
25             var sht21 = new SHT21();
26             sht21.Reset();
27             // Check the serial number in on-chip memory 1
28             // TODO: not fully implemented, now returns zeros
29             packet.Add((byte)0xFC);
30             packet.Add((byte)0xFA);
31             packet.Add((byte)0x0F);
32             sht21.Write(packet.ToArray());
33             packet.Clear();
34             byte[] serialNr = sht21.Read();
35             Assert.AreEqual(serialNr[0], 0x0);
36             Assert.AreEqual(serialNr[1], 0x0);
37             Assert.AreEqual(serialNr[2], 0x0);
38             Assert.AreEqual(serialNr[3], 0x0);
39             Assert.AreEqual(serialNr[4], 0x0);
40             Assert.AreEqual(serialNr[5], 0x0);
41             Assert.AreEqual(serialNr[6], 0x0);
42             Assert.AreEqual(serialNr[7], 0x0);
43             Assert.AreEqual(serialNr[8], 0x0);
44             // Check the serial number in on-chip memory 2
45             // TODO: not fully implemented, now returns zeros
46             packet.Add((byte)0xFD);
47             packet.Add((byte)0xFA);
48             packet.Add((byte)0xC9);
49             sht21.Write(packet.ToArray());
50             packet.Clear();
51             serialNr = sht21.Read();
52             Assert.AreEqual(serialNr[0], 0x0);
53             Assert.AreEqual(serialNr[1], 0x0);
54             Assert.AreEqual(serialNr[2], 0x0);
55             Assert.AreEqual(serialNr[3], 0x0);
56             Assert.AreEqual(serialNr[4], 0x0);
57             Assert.AreEqual(serialNr[5], 0x0);
58             Assert.AreEqual(serialNr[6], 0x0);
59             // Check the user register, write and read back
60             byte userWrite = 0xAA;
61             packet.Add((byte)0xFD);
62             packet.Add((byte)0xE6);
63             packet.Add(userWrite);
64             sht21.Write(packet.ToArray());
65             packet.Clear();
66             packet.Add((byte)0xFC);
67             packet.Add((byte)0xE7);
68             sht21.Write(packet.ToArray());
69             packet.Clear();
70             byte[] userRead = sht21.Read();
71             Assert.AreEqual(userRead[0], userWrite);
72             // Do a soft reset and check reset value of user register
73             packet.Add((byte)0xFD);
74             packet.Add((byte)0xFE);
75             packet.Add((byte)0x0);
76             sht21.Write(packet.ToArray());
77             packet.Clear();
78             packet.Add((byte)0xFC);
79             packet.Add((byte)0xE7);
80             sht21.Write(packet.ToArray());
81             packet.Clear();
82             userRead = sht21.Read();
83             Assert.AreEqual(userRead[0], 0x3A);
84         }
85 
GetSTH21CRC(byte[] array, int nrOfBytes)86         private byte GetSTH21CRC(byte[] array, int nrOfBytes)
87         {
88             const uint POLYNOMIAL = 0x131;  // P(x)=x^8+x^5+x^4+1 = 100110001
89             byte crc = 0;
90             for(byte i = 0; i < nrOfBytes; ++i)
91             {
92                 crc ^= (array[i]);
93                 for(byte bit = 8; bit > 0; --bit)
94                 {
95                     if((crc & 0x80) == 0x80)
96                     {
97                         crc = (byte)(((uint)crc << 1) ^ POLYNOMIAL);
98                     }
99                     else
100                     {
101                         crc = (byte)(crc << 1);
102                     }
103                 }
104             }
105             return crc;
106         }
107 
108         [Test, Ignore("Ignored")]
ReadHumidityTest()109         public void ReadHumidityTest()
110         {
111             List<byte> packet = new List<byte>();
112             var sht21 = new SHT21();
113             sht21.Reset();
114             ////////////////////////////////////////////////////////////
115             // Start measurement, Relative Humidity - hold master - 12-bit resolution
116             packet.Add((byte)0xFD);
117             packet.Add((byte)0xE5);
118             sht21.Write(packet.ToArray());
119             packet.Clear();
120             // Read Relative Humidity sensor data result
121             packet.Add((byte)0xFC);
122             packet.Add((byte)0xE5);
123             sht21.Write(packet.ToArray());
124             packet.Clear();
125             byte[] humidityBytes = sht21.Read();
126             // Check SHT21 CRC
127             byte[] resultArray = new byte[2] { 0, 0 };
128             resultArray[0] = humidityBytes[0];
129             resultArray[1] = humidityBytes[1];
130             byte checkCRC = GetSTH21CRC(resultArray, 2);
131             Assert.AreEqual(checkCRC, humidityBytes[2]);
132             // Assemble data bytes - default precision value is 12 bit
133             UInt32 humidityInt = (UInt32)((((UInt16)humidityBytes[0] << 4) & 0xFF0) + (((UInt16)humidityBytes[1] >> 4) & 0xF));
134             // Calculate relative humidity
135             // RH = -6 + 125 * SRH/2^16
136             double humidity = 125.0 * Convert.ToDouble(humidityInt << 4) / 65536.0 - 6.0;
137             humidity = Math.Round(humidity, 1);
138             Assert.Greater(humidity, 0);
139             Assert.LessOrEqual(humidity, 100);
140             ////////////////////////////////////////////////////////////
141             // Start measurement, Relative Humidity - hold master - 8-bit resolution
142             // Set 8-bit resolution
143             packet.Add((byte)0xFD);
144             packet.Add((byte)0xE6);
145             packet.Add((byte)0x3B);
146             sht21.Write(packet.ToArray());
147             packet.Clear();
148             // Start measurement
149             packet.Add((byte)0xFD);
150             packet.Add((byte)0xE5);
151             sht21.Write(packet.ToArray());
152             packet.Clear();
153             // Read Relative Humidity sensor data result
154             packet.Add((byte)0xFC);
155             packet.Add((byte)0xE5);
156             sht21.Write(packet.ToArray());
157             packet.Clear();
158             humidityBytes = sht21.Read();
159             // Check SHT21 CRC
160             resultArray = new byte[2] { 0, 0 };
161             resultArray[0] = humidityBytes[0];
162             resultArray[1] = humidityBytes[1];
163             checkCRC = GetSTH21CRC(resultArray, 2);
164             Assert.AreEqual(checkCRC, humidityBytes[2]);
165             // Assemble data bytes - precision value is 8 bit
166             humidityInt = (UInt32)(humidityBytes[0] & 0xFF);
167             // Calculate relative humidity
168             // RH = -6 + 125 * SRH/2^16
169             humidity = 125.0 * Convert.ToDouble(humidityInt << 8) / 65536.0 - 6.0;
170             //humidity *= 100;
171             humidity = Math.Round(humidity, 1);
172             Assert.Greater(humidity, 0);
173             Assert.LessOrEqual(humidity, 100);
174             // Start measurement, Relative Humidity - hold master - 8-bit resolution
175             // Set 10-bit resolution
176             packet.Add((byte)0xFD);
177             packet.Add((byte)0xE6);
178             packet.Add((byte)0xBA);
179             sht21.Write(packet.ToArray());
180             packet.Clear();
181             // Start measurement
182             packet.Add((byte)0xFD);
183             packet.Add((byte)0xE5);
184             sht21.Write(packet.ToArray());
185             packet.Clear();
186             // Read Relative Humidity sensor data result
187             packet.Add((byte)0xFC);
188             packet.Add((byte)0xE5);
189             sht21.Write(packet.ToArray());
190             packet.Clear();
191             humidityBytes = sht21.Read();
192             // Check SHT21 CRC
193             resultArray = new byte[2] { 0, 0 };
194             resultArray[0] = humidityBytes[0];
195             resultArray[1] = humidityBytes[1];
196             checkCRC = GetSTH21CRC(resultArray, 2);
197             Assert.AreEqual(checkCRC, humidityBytes[2]);
198             // Assemble data bytes - precision value is 10 bit
199             humidityInt = (UInt32)((((UInt16)humidityBytes[0] << 2) & 0x3FC) + (((UInt16)humidityBytes[1] >> 6) & 0x3));
200             // RH = -6 + 125 * SRH/2^16
201             humidity = 125.0 * Convert.ToDouble(humidityInt << 6) / 65536.0 - 6.0;
202             //humidity *= 100;
203             humidity = Math.Round(humidity, 1);
204             Assert.Greater(humidity, 0);
205             Assert.LessOrEqual(humidity, 100);
206             // Start measurement, Relative Humidity - hold master - 8-bit resolution
207             // Set 11-bit resolution
208             packet.Add((byte)0xFD);
209             packet.Add((byte)0xE6);
210             packet.Add((byte)0xBB);
211             sht21.Write(packet.ToArray());
212             packet.Clear();
213             // Start measurement
214             packet.Add((byte)0xFD);
215             packet.Add((byte)0xE5);
216             sht21.Write(packet.ToArray());
217             packet.Clear();
218             // Read Relative Humidity sensor data result
219             packet.Add((byte)0xFC);
220             packet.Add((byte)0xE5);
221             sht21.Write(packet.ToArray());
222             packet.Clear();
223             humidityBytes = sht21.Read();
224             // Check SHT21 CRC
225             resultArray = new byte[2] { 0, 0 };
226             resultArray[0] = humidityBytes[0];
227             resultArray[1] = humidityBytes[1];
228             checkCRC = GetSTH21CRC(resultArray, 2);
229             Assert.AreEqual(checkCRC, humidityBytes[2]);
230             // Assemble data bytes - precision value is 11 bit
231             humidityInt = (UInt32)((((UInt16)humidityBytes[0] << 3) & 0x7F8) + (((UInt16)humidityBytes[1] >> 5) & 0x7));
232             // Calculate relative humidity
233             // RH = -6 + 125 * SRH/2^16
234             humidity = 125.0 * Convert.ToDouble(humidityInt << 5) / 65536.0 - 6.0;
235             //humidity *= 100;
236             humidity = Math.Round(humidity, 1);
237             Assert.Greater(humidity, 0);
238             Assert.LessOrEqual(humidity, 100);
239         }
240 
241         [Test]
ReadTemperatureTest()242         public void ReadTemperatureTest()
243         {
244             List<byte> packet = new List<byte>();
245             var sht21 = new SHT21();
246             sht21.Reset();
247             // Start measurement, Temperature - hold master
248             packet.Add((byte)0xFD);
249             packet.Add((byte)0xE3);
250             sht21.Write(packet.ToArray());
251             packet.Clear();
252             // Read temperature sensor data result
253             packet.Add((byte)0xFC);
254             packet.Add((byte)0xE3);
255             sht21.Write(packet.ToArray());
256             packet.Clear();
257             byte[] temperatureBytes = sht21.Read();
258             // Check SHT21 CRC
259             // Check SHT21 CRC
260             byte[] resultArray = new byte[2] { 0, 0 };
261             resultArray[0] = temperatureBytes[0];
262             resultArray[1] = temperatureBytes[1];
263             byte checkCRC = GetSTH21CRC(resultArray, 2);
264             Assert.AreEqual(checkCRC, temperatureBytes[2]);
265             // Assemble data bytes - default precision value is 14 bit
266             UInt16 temperatureInt = (UInt16)((((int)temperatureBytes[0] << 6) & 0x3FC0) + (((int)temperatureBytes[1] & 0xFC) >> 2));
267             // Calculate temperature
268             // T = -46.85 + 175.72 * ST/2^16
269             double temperature = 17572.0 * Convert.ToDouble(temperatureInt) / 65536.0 - 46.85;
270             temperature = Math.Round(temperature, 2);
271             Assert.Greater(temperature, 0);
272         }
273     }
274 }
275 
276