jupyterpidaq.Sensors.sensors

  1# Definitions of known sensors for JupyterPiDAQ
  2# By Jonathan Gutow <gutow@uwosh.edu>
  3# June 2019
  4# license GPL3+
  5
  6# class for each sensor and some utility functions
  7
  8import math
  9import numpy as np
 10import logging
 11
 12logger = logging.getLogger(__name__)
 13
 14
 15###
 16# Private Utility functions. WARNING: behavior may change
 17###
 18
 19# Unit conversions
 20
 21def _KtoC(K):
 22    """
 23
 24    :param K: temperature in K
 25    :return: temperature in C
 26    """
 27    return K - 273.15
 28
 29
 30def _CtoF(C):
 31    """
 32
 33    :param C: temperature in C
 34    :return: temperature in F
 35    """
 36    return C * 9.0 / 5.0 + 32.0
 37
 38
 39def _ntc_therm_RtoK(R, A, B, C):
 40    """
 41    Converts resistance of a negative temperature coefficient thermistor to
 42    temperature in Kelvin using the
 43    Steinhart Hart model.
 44    :param R: Resistance in Ohms
 45    :param A: Steinhart Hart A coefficient
 46    :param B: Steinhart Hart B coefficient
 47    :param C: Steinhart Hart C coefficient
 48    :return: Temperature in K
 49    """
 50    K = 1 / (A + B * math.log(R) + C * (math.log(R)) ** 3)
 51    logger.debug('K: ' + str(K))
 52    return K
 53
 54
 55###
 56# End of Private Utility Functions.
 57###
 58
 59###
 60# Public Utility Functions
 61###
 62
 63# Round values to reflect uncertainty/standard deviation
 64
 65def to_reasonable_significant_figures(value, uncertainty):
 66    """
 67    This function will return value rounded to a reasonable number of
 68    significant figures based on the uncertainty. If you are doing this
 69    based on the standard return from the raw voltage or the sensor
 70    definitions in this file it is recommend that this be the standard
 71    deviation of the average, which will often provide about one more digit
 72    than the standard deviation. This will provide a guard digit for further
 73    computations.
 74
 75    :param float value: the value to be rounded
 76    :param float uncertainty: the uncertainty.
 77
 78    :returns float:
 79
 80    Returns: rounded_value a floating point number.
 81    """
 82    decimals = 0
 83    if uncertainty == 0:
 84        decimals = 6
 85    else:
 86        if (uncertainty != float('inf')) and (uncertainty > 0):
 87            decimals = -int(np.floor(np.log10(uncertainty)))
 88    value = np.around(value, decimals=decimals)
 89    return value
 90
 91
 92def to_reasonable_significant_figures_fast(avg, std, avg_std):
 93    """
 94    This function will return values rounded to a reasonable number of
 95    significant figures based on the avg_std. This function requires fewer
 96    compares so is a little more efficient than calling
 97    to_reasonable_significant_figures(value, uncertainty) for avg, std,
 98    avg_std separately.
 99
100    :param float avg: the average value
101    :param float std: the standard deviation
102    :param float avg_std: the estimated standard deviation in avg
103    :returns list:
104
105    Returns: list of rounded values for each [avg, std, avg_std]
106    """
107    decimals = 0
108    if avg_std == 0:
109        decimals = 6
110    else:
111        if (avg_std != float('inf')) and (avg_std > 0):
112            decimals = -int(np.floor(np.log10(avg_std)))
113    avg = np.around(avg, decimals=decimals)
114    std = np.around(std, decimals=decimals)
115    avg_std = np.around(avg_std, decimals=decimals)
116    return [avg, std, avg_std]
117
118
119# Sensor list.
120# TODO: Should be added to when each new sensor class is added.
121
122def listSensors():
123    """
124    Provides a list of the sensor classes provided by this file. The list must
125    be manually updated with each new class.
126    :return: list of classnames
127    """
128    return ['RawAtoD',
129            'BuiltInThermistor',
130            'VernierSSTemp',
131            'VernierGasP',
132            'VernierGasP_OLD',
133            'VernierpH',
134            'VernierFlatpH'
135            ]
136    # TODO: extend this list when each new sensor class is added. RawAtoD
137    #  should always be first in the list.
138
139
140###
141# Sensor Classes
142#
143# Each class must extend the `Class RawAtoD`. See below:
144###
145
146class RawAtoD:
147    """
148    This is the base sensor class which all sensors should extend. See how to
149    do this properly using one of the examples below.
150    This class contains definitions for the raw AtoD return in volts. The
151    digital values are not used as the AtoD may have a builtin pre-amp,
152    so a given digital value has different meanings depending upon the pre-amp
153    setting.
154    """
155
156    def __init__(self, Vdd):
157        """
158        This init should be called first in the init section of any class
159        extending this class (e.g. `super().__init__(Vdd)`). Then set
160        `self.name` and `self.vendor` to the proper values. Append units
161        specific to the sensor to `self.units`. The parameter Vdd must be
162        supplied upon initialization because the output voltage of some
163        sensors depends on Vdd.
164
165        :param float Vdd: the voltage supplied to the sensor by the A-to-D
166         board in case the sensor output depends on this.
167        """
168        self.name = 'Volts at A-to-D'
169        self.vendor = '--'
170        self.units = ['V', 'mV']
171        self.Vdd = Vdd
172        pass
173
174    def getname(self):
175        """
176        Provides a string name for the sensor
177        :return: string containing the sensor name
178        """
179        return self.name
180
181    def getvendor(self):
182        """
183        Provides a string name for the sensor vendor/manufacturer
184        :return: string containing the vendor/manufacturer name
185        """
186        return self.vendor
187
188    def getunits(self):
189        """
190        Provides the string names for the available units for this sensor.
191        These string names are also the functions within this class that
192        return the measurement in those units.
193        :return: units a list of strings.
194        """
195        return self.units
196
197    def V(self, v_avg, v_std, avg_std, avg_vdd):
198        """
199        It is not really necessary to call this function because it just
200        returns the same values that are passed to it.
201        It is provided for consistency with the way sensors units are defined.
202        :param v_avg: v_avg: average voltage from A-to-D
203        :param v_std: standard deviation of the A-to-D measurements
204        :param avg_std: estimate of the standard deviation of v_avg
205        :param float avg_vdd: simultaneously measured average Vdd.
206        :return: [v_avg, v_std, avg_std]
207        """
208        return v_avg, v_std, avg_std
209
210    def mV(self, v_avg, v_std, avg_std, avg_vdd):
211        """
212        Convert the raw AtoD voltage to mV.
213        :param v_avg: v_avg: average voltage from A-to-D
214        :param v_std: standard deviation of the A-to-D measurements
215        :param avg_std: estimate of the standard deviation of v_avg
216        :param float avg_vdd: simultaneously measured average Vdd.
217        :return: [v_avg, v_std, avg_std] converted to mV
218        """
219        return 1000 * v_avg, 1000 * v_std, 1000 * avg_std
220
221
222class BuiltInThermistor(RawAtoD):
223    """
224    This class contains the definitions for builtin thermistor.
225    """
226
227    def __init__(self, Vdd):
228        super().__init__(Vdd)
229        self.name = 'Built-in Thermistor'
230        self.vendor = 'KNARCO'
231        self.units = self.units + ['K', 'C', 'F']
232        self.gains = [1]
233        self.Vdd = Vdd
234        # print('Done initializing builtinthermistor class.')
235        pass
236
237    ###
238    # Sensor specific units. Notice the function names must match the string
239    # used for the units.
240    ###
241
242    def K(self, v_avg, v_std, avg_std, avg_vdd):
243        """
244        The returned values are in K. It is assumed that the distribution is
245        symmetric guassian even in K. This may not be true, but still gives
246        a reasonable estimate of the standard deviation.
247        :param v_avg: average voltage from sensor.
248        :param v_std: standard deviation of voltage from sensor.
249        :param avg_std: estimated standard deviation of the avg.
250        :param float avg_vdd: simultaneously measured average Vdd.
251        :return list:
252
253        Returns: list [K_avg, K_std, K_avg_std]
254         [average temperature in K,
255         standard deviation of temperature in K,
256         estimated standard deviation of the average temperature].
257        """
258        # Correct values based on measured reference voltage
259        v_avg = v_avg * self.Vdd / avg_vdd
260        v_std = v_std * self.Vdd / avg_vdd
261        avg_std = avg_std * self.Vdd / avg_vdd
262        # v_avg to K
263        K_avg = self._VtoK(v_avg)
264        # standard deviation of temperature
265        v_max = v_avg + v_std
266        v_min = v_avg - v_std
267        K_max = self._VtoK(v_max)
268        K_min = self._VtoK(v_min)
269        K_std = (K_max - K_min) / 2.0
270        # assuming a symmetric gaussian error even after transform from volts.
271        # estimated standard deviation of the average temperature
272        v_max = v_avg + avg_std
273        v_min = v_avg - avg_std
274        K_max = self._VtoK(v_max)
275        K_min = self._VtoK(v_min)
276        K_avg_std = (K_max - K_min) / 2.0
277        # assuming a symmetric gaussian error even after transform from volts.
278        return K_avg, K_std, K_avg_std
279
280    def C(self, v_avg, v_std, avg_std, avg_vdd):
281        """
282        The returned values are in deg C. It is assumed that the distribution
283        is symmetric guassian even in deg C. This may not be true, but still
284        gives a reasonable estimate of the standard deviation.
285        :param v_avg: average voltage from sensor.
286        :param v_std: standard deviation of voltage from sensor.
287        :param avg_std: estimated standard deviation of the avg.
288        :param float avg_vdd: simultaneously measured average Vdd.
289        :return list:
290
291        Returns: list [C_avg, C_std, C_avg_std]
292         [average temperature in C, standard deviation of temperature in C,
293            estimated standard deviation of the average temperature].
294        """
295        K_avg, K_std, K_avg_std = self.K(v_avg, v_std, avg_std, avg_vdd)
296        C_avg = _KtoC(K_avg)
297        return C_avg, K_std, K_avg_std
298
299    def F(self, v_avg, v_std, avg_std, avg_vdd):
300        """
301        The returned values are in deg F. It is assumed that the distribution
302        is symmetric guassian even in deg F. This may not be true, but still
303        gives a reasonable estimate of the standard deviation.
304        :param float v_avg: average voltage from sensor.
305        :param float v_std: standard deviation of voltage from sensor.
306        :param float avg_std: estimated standard deviation of the avg.
307        :param float avg_vdd: simultaneously measured average Vdd.
308        :returns list:
309
310        Returns: list [F_avg, F_std, F_avg_std]
311         [average temperature in F, standard deviation of temperature in F,
312         estimated standard deviation of the average temperature].
313        """
314        K_avg, K_std, K_avg_std = self.K(v_avg, v_std, avg_std, avg_vdd)
315        F_avg = _CtoF(_KtoC(K_avg))
316        F_std = K_std * 9.0 / 5.0
317        F_avg_std = K_avg_std * 9.0 / 5.0
318        return F_avg, F_std, F_avg_std
319
320    def _VtoK(self, volts):
321        """
322        :param volts: voltage measurement
323        :return: temperature in K.
324        """
325        # Steinhart Hart coefficients for this thermistor
326        A = 0.0009667974157916105
327        B = 0.00024132572130718138
328        C = 2.077144181533216e-07
329        # Need to stay in sensor range, if get bad voltage throw max or min
330        # possible value alternative for pegging would be to set to 1.649999
331        # which gives < absolute zero.
332        if volts <= 0:
333            volts = 1e-312  # gets about 0 K
334        if volts >= 1.65:
335            volts = 1.649998411  # gets very high T in K
336        R = self.Vdd * 1.0e4 / volts - 2.0e4
337        tempK = _ntc_therm_RtoK(R, A, B, C)
338        return tempK
339
340
341class VernierSSTemp(RawAtoD):
342    """
343    This class contains the definitions for Vernier Stainless Steel Temperature
344    Probe. A 20K thermistor.
345    """
346
347    def __init__(self, Vdd):
348        super().__init__(Vdd)
349        self.name = 'Vernier SS Temperature Probe'
350        self.vendor = 'Vernier'
351        self.units = self.units + ['K', 'C', 'F']
352        self.Vdd = Vdd
353        pass
354
355    ###
356    # Sensor specific units. Notice the function names must match the
357    # string used for the units.
358    ###
359
360    def K(self, v_avg, v_std, avg_std, avg_vdd):
361        """
362        The returned values are in K. It is assumed that the distribution is
363        symmetric guassian even in K. This may not be true, but still gives
364        a reasonable estimate of the standard deviation.
365        :param float v_avg: average voltage from sensor.
366        :param float v_std: standard deviation of voltage from sensor.
367        :param float avg_std: estimated standard deviation of the avg.
368        :param float avg_vdd: simultaneously measured average Vdd.
369        :returns list:
370
371        Returns list [K_avg, K_std, K_avg_std]
372         [average temperature in K, standard deviation of temperature in K,
373         estimated standard deviation of the average temperature].
374        """
375        logger.debug(
376            'voltages in: ' + str(v_avg) + ' ' + str(v_std) + ' ' + str(
377                avg_std))
378        # Correct values based on measured reference voltage
379        v_avg = v_avg * self.Vdd / avg_vdd
380        v_std = v_std * self.Vdd / avg_vdd
381        avg_std = avg_std * self.Vdd / avg_vdd
382        # v_avg to K
383        K_avg = self._VtoK(v_avg)
384        # standard deviation of temperature
385        v_max = v_avg + v_std
386        v_min = v_avg - v_std
387        K_max = self._VtoK(v_min)
388        K_min = self._VtoK(v_max)
389        K_std = (K_max - K_min) / 2.0
390        # assuming a symmetric gaussian error even after transform from volts.
391        # estimated standard deviation of the average temperature
392        v_max = v_avg + avg_std
393        v_min = v_avg - avg_std
394        K_max = self._VtoK(v_min)
395        K_min = self._VtoK(v_max)
396        K_avg_std = (K_max - K_min) / 2.0
397        # assuming a symmetric gaussian error even after transform from volts.
398        logger.debug(
399            'K out: ' + str(K_avg) + ' ' + str(K_std) + ' ' + str(K_avg_std))
400        return K_avg, K_std, K_avg_std
401
402    def C(self, v_avg, v_std, avg_std, avg_vdd):
403        """
404        The returned values are in deg C. It is assumed that the distribution
405        is symmetric guassian even in deg C. This may not be true, but still
406        gives a reasonable estimate of the standard deviation.
407
408        :param float v_avg: average voltage from sensor.
409        :param float v_std: standard deviation of voltage from sensor.
410        :param float avg_std: estimated standard deviation of the avg.
411        :param float avg_vdd: simultaneously measured average Vdd.
412        :return tuple:
413
414        Returns: C_avg, C_std, C_avg_std
415         average temperature in C, standard deviation of temperature in C,
416         estimated standard deviation of the average temperature.
417        """
418        K_avg, K_std, K_avg_std = self.K(v_avg, v_std, avg_std, avg_vdd)
419        C_avg = _KtoC(K_avg)
420        return C_avg, K_std, K_avg_std
421
422    def F(self, v_avg, v_std, avg_std, avg_vdd):
423        """
424        The returned values are in deg F. It is assumed that the
425        distribution is symmetric guassian even in deg F. This may not be
426        true, but still gives a reasonable estimate of the standard
427        deviation.
428
429        :param float v_avg: average voltage from sensor.
430        :param float v_std: standard deviation of voltage from sensor.
431        :param float avg_std: estimated standard deviation of the avg.
432        :param float avg_vdd: simultaneously measured average Vdd.
433
434        :return list:
435
436        Returns: F_avg, F_std, F_avg_std
437         average temperature in F, standard deviation of
438         temperature in F, estimated standard deviation of the average
439         temperature.
440        """
441        K_avg, K_std, K_avg_std = self.K(v_avg, v_std, avg_std, avg_vdd)
442        F_avg = _CtoF(_KtoC(K_avg))
443        F_std = K_std * 9.0 / 5.0
444        F_avg_std = K_avg_std * 9.0 / 5.0
445        return F_avg, F_std, F_avg_std
446
447    def _VtoK(self, volts):
448        """
449        :param volts: voltage measurement
450        :return: temperature in K.
451        """
452        # Steinhart Hart coefficients for this thermistor
453        A = 0.00102119
454        B = 0.000222468
455        C = 1.33342e-07
456        # Need to stay in sensor range, if get bad voltage throw max or min
457        # possible value alternative for pegging would be to set to 1.649999
458        # which gives < absolute zero.
459        if (
460                volts <= 0):
461            # TODO: fix over and underflow for vernier thermistor sensors.
462            volts = 1e-312  # gets high T
463        if volts >= self.Vdd:
464            volts = self.Vdd - 1e-10  # gets low T in K
465        R = volts * 1.5e4 / (self.Vdd - volts)
466        logger.debug('volts: ' + str(volts) + ' R: ' + str(R))
467        tempK = _ntc_therm_RtoK(R, A, B, C)
468        return tempK
469
470
471class VernierGasP(RawAtoD):
472    """
473    This class contains the definitions for Vernier absolute gas pressure
474    sensor, GPS-BTA (post 2011 manufacture).
475    """
476
477    def __init__(self, Vdd):
478        super().__init__(Vdd)
479        self.name = 'Vernier Absolute Gas Pressure Sensor (New)'
480        self.vendor = 'Vernier (manufactured after 2011)'
481        self.units = self.units + ['Pa', 'kPa', 'Bar', 'Torr', 'mmHg', 'atm']
482        self.Vdd = Vdd
483        pass
484
485    ###
486    # Sensor specific units. Notice the function names must match the
487    # string used for the units.
488    ###
489
490    def Pa(self, v_avg, v_std, avg_std, avg_vdd):
491        """
492
493        :param float v_avg: average raw voltage
494        :param float v_std: standard deviation of the raw voltage
495        :param float avg_std: estimated standard deviation of v_avg
496        :param float avg_vdd: the Vdd measured simultaneously with v_avg (not
497        used)
498        :return list:
499
500        Returns: P_avg, P_std, P_avg_std all in Pascals
501        """
502        P_avg = 51710 * v_avg - 25860
503        P_std = 51710 * v_std
504        P_avg_std = 51710 * avg_std
505        return P_avg, P_std, P_avg_std
506
507    def kPa(self, v_avg, v_std, avg_std, avg_vdd):
508        """
509
510        :param float v_avg: average raw voltage
511        :param float v_std: standard deviation of the raw voltage
512        :param float avg_std: estimated standard deviation of v_avg
513        :param float avg_vdd: the Vdd measured simultaneously with v_avg (not
514        used)
515        :return list:
516
517        Returns: P_avg, P_std, P_avg_std all in kiloPascals
518        """
519        P_avg = 51.710 * v_avg - 25.860
520        P_std = 51.710 * v_std
521        P_avg_std = 51.710 * avg_std
522        return P_avg, P_std, P_avg_std
523
524    def Bar(self, v_avg, v_std, avg_std, avg_vdd):
525        """
526
527        :param float v_avg: average raw voltage
528        :param float v_std: standard deviation of the raw voltage
529        :param float avg_std: estimated standard deviation of v_avg
530        :param float avg_vdd: the Vdd measured simultaneously with v_avg (not
531        used)
532        :return list:
533
534        Returns: P_avg, P_std, P_avg_std all in Bars
535        """
536        P_avg = .51710 * v_avg - .25860
537        P_std = .51710 * v_std
538        P_avg_std = .51710 * avg_std
539        return P_avg, P_std, P_avg_std
540
541    def Torr(self, v_avg, v_std, avg_std, avg_vdd):
542        """
543
544        :param float v_avg: average raw voltage
545        :param float v_std: standard deviation of the voltage measurements
546        :param float avg_std: estimate of the standard deviation of the average
547        :param float avg_vdd: the Vdd measured simultaneously with v_avg (
548        not used)
549        :return list:
550
551        Returns: P_avg, P_std, P_avg_std all in Torr
552        """
553        P_avg, P_std, P_avg_std = self.Pa(v_avg, v_std, avg_std, avg_vdd)
554        P_avg = P_avg * 760.0 / 101325
555        P_std = P_std * 760.0 / 101325
556        P_avg_std = P_avg_std * 760.0 / 101325
557        return P_avg, P_std, P_avg_std
558
559    def mmHg(self, v_avg, v_std, avg_std, avg_vdd):
560        """
561
562        :param float v_avg: average raw voltage
563        :param float v_std: standard deviation of the voltage measurements
564        :param float avg_std: estimate of the standard deviation of the average
565        :param float avg_vdd: the Vdd measured simultaneously with v_avg (
566        not used)
567        :return list:
568
569        Returns: P_avg, P_std, P_avg_std all in mmHg
570        """
571        return self.Torr(v_avg, v_std, avg_std, avg_vdd)
572
573    def atm(self, v_avg, v_std, avg_std, avg_vdd):
574        """
575
576        :param float v_avg: average raw voltage
577        :param float v_std: standard deviation of the voltage measurements
578        :param float avg_std: estimate of the standard deviation of the average
579        :param float avg_vdd: the Vdd measured simultaneously with v_avg (
580        not used)
581        :return list:
582
583        Returns: P_avg, P_std, P_avg_std all in atm
584        """
585        P_avg, P_std, P_avg_std = self.Pa(v_avg, v_std, avg_std, avg_vdd)
586        P_avg = P_avg / 101325
587        P_std = P_std / 101325
588        P_avg_std = P_avg_std / 101325
589        return P_avg, P_std, P_avg_std
590
591class VernierGasP_OLD(RawAtoD):
592    """
593    This class contains the definitions for Vernier absolute gas pressure
594    sensor, GPS-BTA (pre 2011 manufacture. Label does not depict a caliper
595    with the registered trademark symbol).
596    """
597
598    def __init__(self, Vdd):
599        super().__init__(Vdd)
600        self.name = 'Vernier Absolute Gas Pressure Sensor (New)'
601        self.vendor = 'Vernier (manufactured after 2011)'
602        self.units = self.units + ['Pa', 'kPa', 'Bar', 'Torr', 'mmHg', 'atm']
603        self.Vdd = Vdd
604        pass
605
606    ###
607    # Sensor specific units. Notice the function names must match the
608    # string used for the units.
609    ###
610
611    def Pa(self, v_avg, v_std, avg_std, avg_vdd):
612        """
613
614        :param float v_avg: average raw voltage
615        :param float v_std: standard deviation of the raw voltage
616        :param float avg_std: estimated standard deviation of v_avg
617        :param float avg_vdd: the Vdd measured simultaneously with v_avg (not
618        used)
619        :return list:
620
621        Returns: P_avg, P_std, P_avg_std all in Pascals
622        """
623        P_avg = 46480 * v_avg
624        P_std = 46480 * v_std
625        P_avg_std = 46480 * avg_std
626        return P_avg, P_std, P_avg_std
627
628    def kPa(self, v_avg, v_std, avg_std, avg_vdd):
629        """
630
631        :param float v_avg: average raw voltage
632        :param float v_std: standard deviation of the raw voltage
633        :param float avg_std: estimated standard deviation of v_avg
634        :param float avg_vdd: the Vdd measured simultaneously with v_avg (not
635        used)
636        :return list:
637
638        Returns: P_avg, P_std, P_avg_std all in kiloPascals
639        """
640        P_avg = 46.480 * v_avg
641        P_std = 46.480 * v_std
642        P_avg_std = 46.480 * avg_std
643        return P_avg, P_std, P_avg_std
644
645    def Bar(self, v_avg, v_std, avg_std, avg_vdd):
646        """
647
648        :param float v_avg: average raw voltage
649        :param float v_std: standard deviation of the raw voltage
650        :param float avg_std: estimated standard deviation of v_avg
651        :param float avg_vdd: the Vdd measured simultaneously with v_avg (not
652        used)
653        :return list:
654
655        Returns: P_avg, P_std, P_avg_std all in Bars
656        """
657        P_avg = .46480 * v_avg
658        P_std = .46480 * v_std
659        P_avg_std = .46480 * avg_std
660        return P_avg, P_std, P_avg_std
661
662    def Torr(self, v_avg, v_std, avg_std, avg_vdd):
663        """
664
665        :param float v_avg: average raw voltage
666        :param float v_std: standard deviation of the voltage measurements
667        :param float avg_std: estimate of the standard deviation of the average
668        :param float avg_vdd: the Vdd measured simultaneously with v_avg (
669        not used)
670        :return list:
671
672        Returns: P_avg, P_std, P_avg_std all in Torr
673        """
674        P_avg, P_std, P_avg_std = self.Pa(v_avg, v_std, avg_std, avg_vdd)
675        P_avg = P_avg * 760.0 / 101325
676        P_std = P_std * 760.0 / 101325
677        P_avg_std = P_avg_std * 760.0 / 101325
678        return P_avg, P_std, P_avg_std
679
680    def mmHg(self, v_avg, v_std, avg_std, avg_vdd):
681        """
682
683        :param float v_avg: average raw voltage
684        :param float v_std: standard deviation of the voltage measurements
685        :param float avg_std: estimate of the standard deviation of the average
686        :param float avg_vdd: the Vdd measured simultaneously with v_avg (
687        not used)
688        :return list:
689
690        Returns: P_avg, P_std, P_avg_std all in mmHg
691        """
692        return self.Torr(v_avg, v_std, avg_std, avg_vdd)
693
694    def atm(self, v_avg, v_std, avg_std, avg_vdd):
695        """
696
697        :param float v_avg: average raw voltage
698        :param float v_std: standard deviation of the voltage measurements
699        :param float avg_std: estimate of the standard deviation of the average
700        :param float avg_vdd: the Vdd measured simultaneously with v_avg (
701        not used)
702        :return list:
703
704        Returns: P_avg, P_std, P_avg_std all in atm
705        """
706        P_avg, P_std, P_avg_std = self.Pa(v_avg, v_std, avg_std, avg_vdd)
707        P_avg = P_avg / 101325
708        P_std = P_std / 101325
709        P_avg_std = P_avg_std / 101325
710        return P_avg, P_std, P_avg_std
711
712class VernierpH(RawAtoD):
713    """
714    This class contains the definitions for Vernier standard pH
715    sensor, PH-BTA.
716    """
717
718    def __init__(self, Vdd):
719        super().__init__(Vdd)
720        self.name = 'Vernier Standard pH Sensor'
721        self.vendor = 'Vernier'
722        self.units = self.units + ['pH']
723        self.Vdd = Vdd
724        pass
725
726    ###
727    # Sensor specific units. Notice the function names must match the
728    # string used for the units.
729    ###
730
731    def pH(self, v_avg, v_std, avg_std, avg_vdd):
732        """
733
734        :param float v_avg: average raw voltage
735        :param float v_std: standard deviation of the raw voltage
736        :param float avg_std: estimated standard deviation of v_avg
737        :param float avg_vdd: the Vdd measured simultaneously with v_avg (not
738        used)
739        :return list:
740
741        Returns: pH_avg, pH_std, pH_avg_std all in pH units
742        """
743        pH_avg = -3.838 * v_avg + 13.720
744        pH_std = 3.838 * v_std
745        pH_avg_std = 3.838 * avg_std
746        return pH_avg, pH_std, pH_avg_std
747
748class VernierFlatpH(RawAtoD):
749    """
750    This class contains the definitions for Vernier flat tris-compatible pH
751    sensor, FPH-BTA.
752    """
753
754    def __init__(self, Vdd):
755        super().__init__(Vdd)
756        self.name = 'Vernier Flat pH Sensor'
757        self.vendor = 'Vernier'
758        self.units = self.units + ['pH']
759        self.Vdd = Vdd
760        pass
761
762    ###
763    # Sensor specific units. Notice the function names must match the
764    # string used for the units.
765    ###
766
767    def pH(self, v_avg, v_std, avg_std, avg_vdd):
768        """
769
770        :param float v_avg: average raw voltage
771        :param float v_std: standard deviation of the raw voltage
772        :param float avg_std: estimated standard deviation of v_avg
773        :param float avg_vdd: the Vdd measured simultaneously with v_avg (not
774        used)
775        :return list:
776
777        Returns: pH_avg, pH_std, pH_avg_std all in pH units
778        """
779        pH_avg = -7.78 * v_avg + 16.34
780        pH_std = 7.78 * v_std
781        pH_avg_std = 7.78 * avg_std
782        return pH_avg, pH_std, pH_avg_std