optoKummenberg

Loading...
Searching...
No Matches
optoKummenberg.registers.InputStage.Analog Class Reference
Inheritance diagram for optoKummenberg.registers.InputStage.Analog:

## Public Member Functions
| __init__ (self, int channel=0, board=None)
| GetLUTsize (self)
| Gets size of lookup table.
| SetLUTvoltages (self, voltage)
| Sets voltages into lookup table (vector based)
| GetLUTvoltages (self)
| Gets voltage values stored in lookup table (vector based)
| SetLUTvalues (self, value)
| Sets values (current of focal power) into lookup table (vector based)
| GetLUTvalues (self)
| Gets values stored in lookup table (vector based)
| SetCalCoefEnable (self, value)
| Enables/disables calibrated input, 0 = disabled, 1 = enabled.
| SetLUTtype (self, value)
| Sets unit type of the values stored in lookup table, 0 = current, 1 = focal power.
| GetLUTtype (self)
| Gets unit type of the values stored in lookup table, 0 = current, 1 = focal power.
| SetExtrapolationType (self, value)
| Sets extrapolation type, 0 = constant, 1 = linear.
| GetActiveUnitType (self)
| Gets unit type determined by active control stage system.
| GetMinimum (self)
| SetMinimum (self, value)
| GetMaximum (self)
| SetMaximum (self, value)
| GetMappingMinimum (self)
| SetMappingMinimum (self, value)
| GetMappingMaximum (self)
| SetMappingMaximum (self, value)
Public Member Functions inherited from optoKummenberg.registers.ClassAbstracts.InputStage
| __init__ (self, int or None channel=0, board=None)
| SetAsInput (self)
Public Member Functions inherited from optoKummenberg.registers.ClassAbstracts.System
| __init__ (self, int or None channel=None, board=None)
| set_register (self, str or int register_name_or_id, value, bool set_internal=False)
| set_register_id (self, int register_id, value, type=None)
| get_register (self, str or int register_name_or_id)
| get_register_id (self, int register_id)
| get_register_names (self)

## Static Public Member Functions
| help ()

## Public Attributes
int | sys_id = 0x58 | channel
dict | adc_value
dict | unit
dict | minimum
dict | maximum
dict | mapping_minimum
dict | mapping_maximum
dict | calCoefEnable
dict | LUTinputType
dict | LUTextrapolationType
dict | norm_value
dict | LUT_size
dict | LUT_voltage = {'id': self.sys_id << 8, 'type': float}
dict | LUT_value = {'id': self.sys_id << 8 | 0x01, 'type': float}
Public Attributes inherited from optoKummenberg.registers.ClassAbstracts.System
| name = self.__class__.__name__
| register_list = self._get_register_list()

## Protected Attributes
dict | _unitranges = {'A': [-1, 1]}
bool | _readonly = False
Protected Attributes inherited from optoKummenberg.registers.ClassAbstracts.System
| _channel = channel
| _board = board

## Additional Inherited Members
Protected Member Functions inherited from optoKummenberg.registers.ClassAbstracts.System
| _get_register_list (self)
Static Protected Attributes inherited from optoKummenberg.registers.ClassAbstracts.System
bool | _is_a_system = False

## Detailed Description

        Input Channel Systems - Analog Input
        System ID: 0x58 through 0x5f

        +-------------------+------+-------------+--------------------+-------------+---------+------------------------+
        | Register Name     | Id   | Type        | Unit               | Range       | Default | Comment                |
        +===================+======+=============+====================+=============+=========+========================+
        | ADC raw value     |0x01  | uint 32-bit | Volt               |0            | 0       | Converted ADC raw value|
        +-------------------+------+-------------+--------------------+-------------+---------+------------------------+
        | Active input type |0x01  | uint 32-bit | UnitType           |0            | 0       | Read only              |
        +-------------------+------+-------------+--------------------+-------------+---------+------------------------+
        | Minimum Current   |0x02  | float 32-bit| Volt               |             | 0       |                        |
        +-------------------+------+-------------+--------------------+-------------+---------+------------------------+
        | Maximum Current   |0x03  | float 32-bit| Volt               |             | 0       |                        |
        +-------------------+------+-------------+--------------------+-------------+---------+------------------------+
        | Minimum Diopter   |0x04  | float 32-bit| Dpt                |             | 0       |                        |
        +-------------------+------+-------------+--------------------+-------------+---------+------------------------+
        | Maximum Diopter   |0x05  | float 32-bit| Dpt                |             | 0       |                        |
        +-------------------+------+-------------+--------------------+-------------+---------+------------------------+
        | Cal coef enable   |0x06  | uint 32-bit | None               |             | 0       | Enable calibrated input|
        +-------------------+------+-------------+--------------------+-------------+---------+------------------------+
        | Analog input type |0x07  | uint 32-bit | A | Dpt            |             | 0       | LUT Unit type          |
        +-------------------+------+-------------+--------------------+-------------+---------+------------------------+
        | Extrapolation type|0x08  | uint 32-bit | None               |             | 0       | constant=0 or linear=1 |
        +-------------------+------+-------------+--------------------+-------------+---------+------------------------+

        registers table 1:

        +--------------------------------+---------------+-------------------------+-----------------------------------+
        | Analogue Input Unit            | Default       | Description             | Format and value                  |
        +================================+===============+=========================+===================================+
        | voltages -> LUT table values   | 0             | 1.voltage               | max 10 * float                    |
        +--------------------------------+---------------+-------------------------+-----------------------------------+
        | current/dpt -> LUT table values| 0             | 2.value(current/FP)     | max 10 & same as voltages * float |
        +--------------------------------+---------------+-------------------------+-----------------------------------+
        | Analog input cal.coefficients  | {0,1,0,0,0,0} | 5th grade polynomial    |    6 * float (24 bytes)           |
        +--------------------------------+---------------+-------------------------+-----------------------------------+

## Constructor & Destructor Documentation

## ◆ __init__()

optoKummenberg.registers.InputStage.Analog.__init__ | ( |  | self,
|  | int | channel = 0,
|  |  | board = None )

## Member Function Documentation

## ◆ GetActiveUnitType()

optoKummenberg.registers.InputStage.Analog.GetActiveUnitType | ( |  | self | ) |

Gets unit type determined by active control stage system.

## ◆ GetLUTsize()

optoKummenberg.registers.InputStage.Analog.GetLUTsize | ( |  | self | ) |

Gets size of lookup table.

## ◆ GetLUTtype()

optoKummenberg.registers.InputStage.Analog.GetLUTtype | ( |  | self | ) |

Gets unit type of the values stored in lookup table, 0 = current, 1 = focal power.

## ◆ GetLUTvalues()

optoKummenberg.registers.InputStage.Analog.GetLUTvalues | ( |  | self | ) |

Gets values stored in lookup table (vector based)

## ◆ GetLUTvoltages()

optoKummenberg.registers.InputStage.Analog.GetLUTvoltages | ( |  | self | ) |

Gets voltage values stored in lookup table (vector based)

## ◆ GetMappingMaximum()

optoKummenberg.registers.InputStage.Analog.GetMappingMaximum | ( |  | self | ) |

## ◆ GetMappingMinimum()

optoKummenberg.registers.InputStage.Analog.GetMappingMinimum | ( |  | self | ) |

## ◆ GetMaximum()

optoKummenberg.registers.InputStage.Analog.GetMaximum | ( |  | self | ) |

## ◆ GetMinimum()

optoKummenberg.registers.InputStage.Analog.GetMinimum | ( |  | self | ) |

## ◆ help()

optoKummenberg.registers.InputStage.Analog.help | ( |  | ) |
| static

## ◆ SetCalCoefEnable()

optoKummenberg.registers.InputStage.Analog.SetCalCoefEnable | ( |  | self,
|  |  | value )

Enables/disables calibrated input, 0 = disabled, 1 = enabled.

## ◆ SetExtrapolationType()

optoKummenberg.registers.InputStage.Analog.SetExtrapolationType | ( |  | self,
|  |  | value )

Sets extrapolation type, 0 = constant, 1 = linear.

## ◆ SetLUTtype()

optoKummenberg.registers.InputStage.Analog.SetLUTtype | ( |  | self,
|  |  | value )

Sets unit type of the values stored in lookup table, 0 = current, 1 = focal power.

## ◆ SetLUTvalues()

optoKummenberg.registers.InputStage.Analog.SetLUTvalues | ( |  | self,
|  |  | value )

Sets values (current of focal power) into lookup table (vector based)

## ◆ SetLUTvoltages()

optoKummenberg.registers.InputStage.Analog.SetLUTvoltages | ( |  | self,
|  |  | voltage )

Sets voltages into lookup table (vector based)

## ◆ SetMappingMaximum()

optoKummenberg.registers.InputStage.Analog.SetMappingMaximum | ( |  | self,
|  |  | value )

## ◆ SetMappingMinimum()

optoKummenberg.registers.InputStage.Analog.SetMappingMinimum | ( |  | self,
|  |  | value )

## ◆ SetMaximum()

optoKummenberg.registers.InputStage.Analog.SetMaximum | ( |  | self,
|  |  | value )

## ◆ SetMinimum()

optoKummenberg.registers.InputStage.Analog.SetMinimum | ( |  | self,
|  |  | value )

## Member Data Documentation

## ◆ _readonly

bool optoKummenberg.registers.InputStage.Analog._readonly = False
| protected

## ◆ _unitranges

dict optoKummenberg.registers.InputStage.Analog._unitranges = {'A': [-1, 1]}
| protected

## ◆ adc_value

dict optoKummenberg.registers.InputStage.Analog.adc_value

Initial value:
= {'id': self.sys_id << 8 | 0x00,
'type': float,
'unit': None,
'range': None,
'default': 0,
'value': 0}

## ◆ calCoefEnable

dict optoKummenberg.registers.InputStage.Analog.calCoefEnable

Initial value:
= {'id': self.sys_id << 8 | 0x06,
'type': int,
'unit': [None],
'range': None,
'default': 0,
'value': 0}

## ◆ LUT_size

dict optoKummenberg.registers.InputStage.Analog.LUT_size

Initial value:
= {'id': self.sys_id << 8 | 0x0A,
'type': int,
'unit': None,
'range': None,
'default': 0,
'value': 0}

## ◆ LUT_value

optoKummenberg.registers.InputStage.Analog.LUT_value = {'id': self.sys_id << 8 | 0x01, 'type': float}

## ◆ LUT_voltage

optoKummenberg.registers.InputStage.Analog.LUT_voltage = {'id': self.sys_id << 8, 'type': float}

## ◆ LUTextrapolationType

dict optoKummenberg.registers.InputStage.Analog.LUTextrapolationType

Initial value:
= {'id': self.sys_id << 8 | 0x08,
'type': int,
'unit': [None],
'range': None,
'default': 0,
'value': 0}

## ◆ LUTinputType

dict optoKummenberg.registers.InputStage.Analog.LUTinputType

Initial value:
= {'id': self.sys_id << 8 | 0x07,
'type': int,
'unit': [None],
'range': None,
'default': 0,
'value': 0}

## ◆ mapping_maximum

dict optoKummenberg.registers.InputStage.Analog.mapping_maximum

Initial value:
= {'id': self.sys_id << 8 | 0x05,
'type': float,
'unit': ['A', None, 'Degrees'],
'range': None,
'default': 0,
'value': 0}

## ◆ mapping_minimum

dict optoKummenberg.registers.InputStage.Analog.mapping_minimum

Initial value:
= {'id': self.sys_id << 8 | 0x04,
'type': float,
'unit': 'A',
'range': [-1, 1],
'default': 0,
'value': 0}

## ◆ maximum

dict optoKummenberg.registers.InputStage.Analog.maximum

Initial value:
= {'id': self.sys_id << 8 | 0x03,
'type': float,
'unit': 'Volt',
'range': None,
'default': 0.0,
'value': 0.0}

## ◆ minimum

dict optoKummenberg.registers.InputStage.Analog.minimum

Initial value:
= {'id': self.sys_id << 8 | 0x02,
'type': float,
'unit': 'Volt',
'range': None,
'default': 0.0,
'value': 0.0}

## ◆ norm_value

dict optoKummenberg.registers.InputStage.Analog.norm_value

Initial value:
= {'id': self.sys_id << 8 | 0x09,
'type': float,
'unit': None,
'range': None,
'default': 0,
'value': 0}

## ◆ sys_id

int optoKummenberg.registers.InputStage.Analog.sys_id = 0x58 | channel

## ◆ unit

dict optoKummenberg.registers.InputStage.Analog.unit

Initial value:
= {'id': self.sys_id << 8 | 0x01,
'type': int,
'unit': ['A'],
'range': {0: 'Current'},
'default': 0,
'value': 0}

The documentation for this class was generated from the following file:

- C:/git/142-421-00_optoKummenberg/src/main/python/optoKummenberg/registers/InputStage.py