def dp(number, min_value, max_value, default):
            if not isinstance(min_value, str):
                min_value = Sint(min_value, 16)

            if not isinstance(max_value, str):
                max_value = Sint(max_value, 16)

            return dummy_parameter(number=number,
                                   datatype=Sint,
                                   min_value=min_value,
                                   max_value=max_value,
                                   default=Sint(default, 16))
Exemple #2
0
 def test_default_int(self):
     parameter = dummy_parameter_from_line(default='10')
     self.assertEqual(parameter.default, Uint(10, 16))
     
     parameter = dummy_parameter_from_line(
         default='-10', format_='s16')
     self.assertEqual(parameter.default, Sint(-10, 16))
Exemple #3
0
 def set_temperature(self, value: int):
     """Set the temperature.
     
     Note that *value* can also be negative.
     """
     self._kwargs['temperature'] = Sint(value, bits=16)
     return self
Exemple #4
0
 def __init__(self, parameters=PARAMETERS):
     """
     __init__(parameters=PARAMETERS)
     
     Initialize a new :class:`TelegramBuilder`.
     
     Args:
         parameters: The object to be assigned to :attr:`parameters`.
     """
     self.parameters = parameters
     
     # Keyword arguments used to create a telegram.
     self._kwargs = {
         'parameter_code':   Bin(4 * '0', bits=4),
         'parameter_number': Uint(0,  bits=11),
         'parameter_index':  Uint(0,  bits=8),
         'parameter_value':  Uint(0,  bits=32),
         'flag_bits':        Bin(16 * '0', bits=16),
         'frequency':        Uint(0,  bits=16),
         'temperature':      Sint(0,  bits=16),
         'current':          Uint(0,  bits=16,),
         'voltage':          Uint(0,  bits=16),
     }
     # parameter_value and parameter_mode are special cases.
     # These variables store the values given by the user, and the final
     # values used as arguments are only determined when the telegram is
     # created.
     
     # __init__ and set_parameter_value set this to a int or a float,
     # and from_bytes to a bytes object.
     self._parameter_value = 0
     
     # __init__ and set_parameter_mode set this to a string, and from_bytes
     # to a Bin object.
     self._parameter_mode = 'none'
Exemple #5
0
    def from_bytes(self, bytes_):
        """Read the contents of the telegram from a :class:`bytes` object.
        
        The type of :attr:`parameter_value <Telegram.parameter_value>`
        depends on :attr:`parameter_number <Telegram.parameter_number>`,
        and is assigned automatically. If *bytes_* contains a parameter 
        number that doesn't exist, a :class:`ValueError` is raised.
        
        If the parameter isn't accessed (i.e. the parameter mode is set to 
        ``'none'`` or code to ``'0000'``), invalid parameter numbers, such as
        the default value of 0, are permitted.
        In that case, the parameter type is set to
        :class:`~turboctl.telegram.datatypes.Uint`.
        
        Note that this isn't a class method; a :class:`TelegramBuilder` must
        first be initialized normally with :meth:`__init__`, after which
        this method may be called.
        
        Raises:
            ValueError: If *bytes_* doesn't represent a valid telegram.
        """
        self._check_valid_telegram(bytes_)
        
        code_and_number_bits = Bin(bytes_[3:5])    
        self._kwargs = {
            'parameter_number':     Uint(code_and_number_bits[5:16]),
            'parameter_index':      Uint(bytes_[6]),
            'flag_bits':            Bin(bytes_[11:13])[::-1],
            'frequency':            Uint(bytes_[13:15]),
            'temperature':          Sint(bytes_[15:17]),
            'current':              Uint(bytes_[17:19]),
            'voltage':              Uint(bytes_[21:23])        
        }
        
        self._parameter_value = bytes_[7:11]
        self._parameter_mode = Bin(code_and_number_bits[0:4])

        return self
Exemple #6
0
 def test_min_max_int(self):
     parameter = dummy_parameter_from_line(
         min_value='-10', max_value='100', format_='s16')
     self.assertEqual(parameter.min_value, Sint(-10, 16))
     self.assertEqual(parameter.max_value, Sint(100, 16))
 def test_max_value_as_reference(self):
     self.assertEqual(self.pc.parameters[5].max_value, Sint(1, 16))
     self.write_test(self.upper.number, 2)
     self.assertEqual(self.pc.parameters[5].max_value, Sint(2, 16))
 def test_min_value_as_reference(self):
     self.assertEqual(self.pc.parameters[5].min_value, Sint(-1, 16))
     self.write_test(self.lower.number, -2)
     self.assertEqual(self.pc.parameters[5].min_value, Sint(-2, 16))
Exemple #9
0
 def test_bits_default_value(self):
     self.assertEqual(Uint(1).bits, 8)
     self.assertEqual(Sint(-1).bits, 8)
     self.assertEqual(Float(1.0).bits, 32)
     self.assertEqual(Float(1).bits, 32)
     self.assertEqual(Bin(1).bits, 8)
Exemple #10
0
 def test_sint_from_int_sets_attributes_correctly(self, i_and_bits):
     i, bits = i_and_bits
     sint = Sint(i, bits)
     self.assertEqual(sint.value, i)
     self.assertEqual(sint.bits, bits)