| optoMDC

Loading...
Searching...
No Matches
optoMDC.registers.mre3_registers.MRE3BoardEEPROM Class Reference
Inheritance diagram for optoMDC.registers.mre3_registers.MRE3BoardEEPROM:

## Public Member Functions
| __init__ (self, board=None)
| GetEepromVersion (self)
| GetEepromSubVersion (self)
| GetSerialNumber (self)
| GetI2Caddr (self)
| SetI2Caddr (self, addr)
| GetFEautostart (self)
| SetFEautostart (self, val)
| GetFEvoltage (self)
| SetFEvoltage (self, val)
| GetPWMfreq (self)
| SetPWMfreq (self, val)
| SetPWMenableChanMask (self, mask)
| GetPWMenableChanMask (self)
| SetDeviceDetectChanMask (self, val)
| GetDeviceDetectChanMask (self)
| SetDevice3V3chanMask (self, val)
| GetDevice3V3chanMask (self)
| SetPStempLimit (self, val)
| GetPStempLimit (self)
| SetPStempHyst (self, val)
| GetPStempHyst (self)
| SetOStempLimit (self, val)
| GetOStempLimit (self)
| SetOStempHyst (self, val)
| GetOStempHyst (self)
| SetStartControlMode (self, val)
| GetStartControlMode (self)
| GetCalTimestamp (self)
| SetControlSetup (self, addr)
| GetControlSetup (self)
| SetSlaveNumOfRegisters (self, addr)
| GetSlaveNumOfRegisters (self)
| SetPowerOnDelay (self, addr)
| GetPowerOnDelay (self)
| GetEEPROMParsingResult (self)
| SetPositiveCurrentLimitChannel0 (self, addr)
| GetPositiveCurrentLimitChannel0 (self)
| SetNegativeCurrentLimitChannel0 (self, addr)
| GetNegativeCurrentLimitChannel0 (self)
| SetPositiveCurrentLimitChannel1 (self, addr)
| GetPositiveCurrentLimitChannel1 (self)
| SetNegativeCurrentLimitChannel1 (self, addr)
| GetNegativeCurrentLimitChannel1 (self)
| GetDeviceI2CclockFreq (self)
| SetDeviceI2CclockFreq (self, value)
| VerifyEEPROM (self, index, vector)
| LockEEPROM (self, enable=True)
| SetSerialNumber (self, serial)
| SetCalTimestamp (self, timestamp)

## Static Public Member Functions
| help ()

## Public Attributes
dict | eeprom_version
dict | eeprom_subversion
dict | part_number
dict | part_config
dict | prod_version
dict | I2C_slave_addr
dict | FE_autostart
dict | FE_voltage
dict | PWM_freq
dict | PWM_enable_chan_mask
dict | Device_detect_chan_mask
dict | Device_3V3_state_chan_mask
dict | PS_temp_limit
dict | PS_temp_hyst
dict | OS_temp_limit
dict | OS_temp_hyst
dict | StartControlMode
dict | Cal_timestamp
dict | Input_control_setup
dict | I2C_slave_num_of_registers
dict | power_on_delay
dict | board_EEPROM_parsing_result
dict | positive_current_limit_channel0
dict | negative_current_limit_channel0
dict | positive_current_limit_channel1
dict | negative_current_limit_channel1
dict | dev_I2C_clock_freq
dict | eeprom = {'id': self.sys_id << 8, 'type': bytes}
dict | serial_number = {'id': self.sys_id << 8 | 0x01, 'type': bytes}

## Static Protected Attributes
bool | _is_a_system = False

## Detailed Description

    * Board EEPROM system ID: <b>0x20</b>
    *
    * Board EEPROM system provides read and write functionality to the EEPROM located in the driver.
    * By default EEPROM data are write protected. To write data, the user has to explicitly unlock
    * the EEPROM by writing the key value to the lock register.
    *
    * ## Register Map:
    *
    * | Address | Name                           | Default Value | Description                                                       | Type   | Access    |
    * |---------|--------------------------------|---------------|-------------------------------------------------------------------|--------|-----------|
    * | 0x2000  | Lock                           | 1             | write the key to unlock, anything else to lock                    | float  | read write| Key value: 0x3f4744f6 (float 0.778396)
    * | 0x2001  | Board EEPROM version           | N/A           |                                                                   | uint16 | read only |
    * | 0x2002  | Board EEPROM subversion        | N/A           |                                                                   | uint8  | read only |
    * | 0x2003  | Part number                    | N/A           | Part number as an integer (2000mA->14521500, 500mA->14521400)     | uint32 | read only |
    * | 0x2004  | Part configuration             | N/A           |                                                                   | uint8  | read only |
    * | 0x2005  | Product version                | N/A           |                                                                   | uint8  | read only |
    * | 0x2006  | NOT USED                       | true or 1     | DHCP enabled if not 0                                             | bool   | read write|
    * | 0x2007  | NOT USED                       | 5000          |                                                                   | bool   | read write|
    * | 0x2008  | NOT USED                       | 30311         |                                                                   | bool   | read write|
    * | 0x2009  | I2C slave address              | 0x03          |                                                                   | uint8  | read write|
    * | 0x200A  | FE_autostart                   | true or 1     | Autostart if value!=0                                             | uint8  | read write|
    * | 0x200B  | FE_voltage                     | 18.0          |                                                                   | float  | read write|
    * | 0x200C  | PWM_freq                       | 0             | Startup PWM freq: 0=400kHz, 1=500kHz, 2=600kHz, 3=1MHz, 4=1.2MHz  | uint8  | read write|
    * | 0x200D  | PWM_enable_chan_mask           | 3            | Enable output PWM driver IC on channel (bitwise)                  | uint8  | read write|
    * | 0x200E  | Device_detect_chan_mask        | 3            | Enable autodetection on channel (bitwise)                         | uint8  | read write|
    * | 0x200F  | Device_3V3_state_chan_mask     | 0             | Enable device 3V3 startup state on channel (bitwise)              | uint8  | read write|
    * | 0x2010  | PS_temp_limit                  | 80            | Power supply temperature limit for shutdown                       | float  | read write|
    * | 0x2011  | PS_temp_hyst                   | 10            | Power supply temperature hysteresis for restart                   | float  | read write|
    * | 0x2012  | OS_temp_limit                  | 80            | Output stage temperature limit for shutdown                       | float  | read write|
    * | 0x2013  | OS_temp_hyst                   | 10            | Output stage temperature hysteresis for restart                   | float  | read write|
    * | 0x2014  | Start_auto_config              | 0             | 1=internal or 2=ext.triger starts auto-actuation (0=off)          | uint32 | read write|
    * | 0x2015  | Calibration Time-stamp         | N/A           | Unix Time format (seconds since 1.1.1970)                         | uint32 | read write|
    * | 0x2016  | UART baudrate configuration    | 0-Autobaudrate| Configuration of UART baudrate in Baud/s, 0 means Autobaudrate    | uint32 | read write|
    * | 0x2017  | Slave I2C register count       | 2             | Set # of registers which can be read in one SignalFlow loop 1/2/4 | uint32 | read write|
    * | 0x2018  | Power On Delay                 | 0             | Delay before board initialisation in milliseconds (0-65535)       | uint32 | read write|
    * | 0x2019  | Board EEPROM Parsing result    | 0             | Result of Board EEPROM parsing. Value 0 means OK. See error codes | uint32 | read only |
    * | 0x201A  | Positive current limit chan0   | 1130          | Positive current limit for unknown devices in mA - chan0          | uint16 | read write|
    * | 0x201B  | Negative current limit chan0   | 1130          | Negative current limit for unknown devices in mA - chan0          | uint16 | read write|
    * | 0x201C  | Positive current limit chan1   | 1130          | Positive current limit for unknown devices in mA - chan1          | uint16 | read write|
    * | 0x201D  | Negative current limit chan1   | 1130          | Negative current limit for unknown devices in mA - chan1          | uint16 | read write|
    * | 0x2022  | Device I2C clock frequency     | 100           | Device I2C clock freq. in kHz: allowed values: 25, 50, 100, 200, 400 kHz| uint16 | read write|
    *
    * The board EEPROM system supports the following vectors (vectors have their own address space):
    *
    * | Address | Name                           | Default  | Description                 | Format and value |
    * |---------|--------------------------------|----------|-----------------------------|------------------|
    * | 0x2000  | Board EEPROM                   |   N/A    | supports bytes up to 0x2000 |                  |
    * | 0x2001  | Board serial number            |   N/A    | 8 bytes                     | read only        |
    * |---------|--------------------------------|----------|-----------------------------|------------------|

## Constructor & Destructor Documentation

## ◆ __init__()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.__init__ | ( |  | self,
|  |  | board = None )

## Member Function Documentation

## ◆ GetCalTimestamp()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetCalTimestamp | ( |  | self | ) |

## ◆ GetControlSetup()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetControlSetup | ( |  | self | ) |

## ◆ GetDevice3V3chanMask()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetDevice3V3chanMask | ( |  | self | ) |

## ◆ GetDeviceDetectChanMask()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetDeviceDetectChanMask | ( |  | self | ) |

## ◆ GetDeviceI2CclockFreq()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetDeviceI2CclockFreq | ( |  | self | ) |

## ◆ GetEEPROMParsingResult()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetEEPROMParsingResult | ( |  | self | ) |

## ◆ GetEepromSubVersion()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetEepromSubVersion | ( |  | self | ) |

## ◆ GetEepromVersion()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetEepromVersion | ( |  | self | ) |

## ◆ GetFEautostart()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetFEautostart | ( |  | self | ) |

## ◆ GetFEvoltage()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetFEvoltage | ( |  | self | ) |

## ◆ GetI2Caddr()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetI2Caddr | ( |  | self | ) |

## ◆ GetNegativeCurrentLimitChannel0()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetNegativeCurrentLimitChannel0 | ( |  | self | ) |

## ◆ GetNegativeCurrentLimitChannel1()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetNegativeCurrentLimitChannel1 | ( |  | self | ) |

## ◆ GetOStempHyst()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetOStempHyst | ( |  | self | ) |

## ◆ GetOStempLimit()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetOStempLimit | ( |  | self | ) |

## ◆ GetPositiveCurrentLimitChannel0()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetPositiveCurrentLimitChannel0 | ( |  | self | ) |

## ◆ GetPositiveCurrentLimitChannel1()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetPositiveCurrentLimitChannel1 | ( |  | self | ) |

## ◆ GetPowerOnDelay()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetPowerOnDelay | ( |  | self | ) |

## ◆ GetPStempHyst()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetPStempHyst | ( |  | self | ) |

## ◆ GetPStempLimit()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetPStempLimit | ( |  | self | ) |

## ◆ GetPWMenableChanMask()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetPWMenableChanMask | ( |  | self | ) |

## ◆ GetPWMfreq()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetPWMfreq | ( |  | self | ) |

## ◆ GetSerialNumber()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetSerialNumber | ( |  | self | ) |

## ◆ GetSlaveNumOfRegisters()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetSlaveNumOfRegisters | ( |  | self | ) |

## ◆ GetStartControlMode()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.GetStartControlMode | ( |  | self | ) |

## ◆ help()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.help | ( |  | ) |
| static

## ◆ LockEEPROM()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.LockEEPROM | ( |  | self,
|  |  | enable = True )

## ◆ SetCalTimestamp()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetCalTimestamp | ( |  | self,
|  |  | timestamp )

## ◆ SetControlSetup()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetControlSetup | ( |  | self,
|  |  | addr )

## ◆ SetDevice3V3chanMask()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetDevice3V3chanMask | ( |  | self,
|  |  | val )

## ◆ SetDeviceDetectChanMask()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetDeviceDetectChanMask | ( |  | self,
|  |  | val )

## ◆ SetDeviceI2CclockFreq()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetDeviceI2CclockFreq | ( |  | self,
|  |  | value )

## ◆ SetFEautostart()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetFEautostart | ( |  | self,
|  |  | val )

## ◆ SetFEvoltage()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetFEvoltage | ( |  | self,
|  |  | val )

## ◆ SetI2Caddr()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetI2Caddr | ( |  | self,
|  |  | addr )

## ◆ SetNegativeCurrentLimitChannel0()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetNegativeCurrentLimitChannel0 | ( |  | self,
|  |  | addr )

## ◆ SetNegativeCurrentLimitChannel1()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetNegativeCurrentLimitChannel1 | ( |  | self,
|  |  | addr )

## ◆ SetOStempHyst()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetOStempHyst | ( |  | self,
|  |  | val )

## ◆ SetOStempLimit()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetOStempLimit | ( |  | self,
|  |  | val )

## ◆ SetPositiveCurrentLimitChannel0()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetPositiveCurrentLimitChannel0 | ( |  | self,
|  |  | addr )

## ◆ SetPositiveCurrentLimitChannel1()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetPositiveCurrentLimitChannel1 | ( |  | self,
|  |  | addr )

## ◆ SetPowerOnDelay()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetPowerOnDelay | ( |  | self,
|  |  | addr )

## ◆ SetPStempHyst()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetPStempHyst | ( |  | self,
|  |  | val )

## ◆ SetPStempLimit()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetPStempLimit | ( |  | self,
|  |  | val )

## ◆ SetPWMenableChanMask()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetPWMenableChanMask | ( |  | self,
|  |  | mask )

## ◆ SetPWMfreq()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetPWMfreq | ( |  | self,
|  |  | val )

## ◆ SetSerialNumber()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetSerialNumber | ( |  | self,
|  |  | serial )

## ◆ SetSlaveNumOfRegisters()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetSlaveNumOfRegisters | ( |  | self,
|  |  | addr )

## ◆ SetStartControlMode()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.SetStartControlMode | ( |  | self,
|  |  | val )

## ◆ VerifyEEPROM()

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.VerifyEEPROM | ( |  | self,
|  |  | index,
|  |  | vector )

## Member Data Documentation

## ◆ _is_a_system

bool optoMDC.registers.mre3_registers.MRE3BoardEEPROM._is_a_system = False
| static protected

## ◆ board_EEPROM_parsing_result

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.board_EEPROM_parsing_result

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

## ◆ Cal_timestamp

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.Cal_timestamp

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

## ◆ dev_I2C_clock_freq

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.dev_I2C_clock_freq

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

## ◆ Device_3V3_state_chan_mask

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.Device_3V3_state_chan_mask

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

## ◆ Device_detect_chan_mask

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.Device_detect_chan_mask

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

## ◆ eeprom

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.eeprom = {'id': self.sys_id << 8, 'type': bytes}

## ◆ eeprom_subversion

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.eeprom_subversion

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

## ◆ eeprom_version

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.eeprom_version

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

## ◆ FE_autostart

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.FE_autostart

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

## ◆ FE_voltage

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.FE_voltage

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

## ◆ I2C_slave_addr

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.I2C_slave_addr

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

## ◆ I2C_slave_num_of_registers

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.I2C_slave_num_of_registers

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

## ◆ Input_control_setup

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.Input_control_setup

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

## ◆ negative_current_limit_channel0

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.negative_current_limit_channel0

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

## ◆ negative_current_limit_channel1

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.negative_current_limit_channel1

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

## ◆ OS_temp_hyst

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.OS_temp_hyst

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

## ◆ OS_temp_limit

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.OS_temp_limit

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

## ◆ part_config

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.part_config

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

## ◆ part_number

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.part_number

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

## ◆ positive_current_limit_channel0

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.positive_current_limit_channel0

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

## ◆ positive_current_limit_channel1

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.positive_current_limit_channel1

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

## ◆ power_on_delay

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.power_on_delay

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

## ◆ prod_version

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.prod_version

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

## ◆ PS_temp_hyst

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.PS_temp_hyst

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

## ◆ PS_temp_limit

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.PS_temp_limit

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

## ◆ PWM_enable_chan_mask

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.PWM_enable_chan_mask

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

## ◆ PWM_freq

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.PWM_freq

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

## ◆ serial_number

optoMDC.registers.mre3_registers.MRE3BoardEEPROM.serial_number = {'id': self.sys_id << 8 | 0x01, 'type': bytes}

## ◆ StartControlMode

dict optoMDC.registers.mre3_registers.MRE3BoardEEPROM.StartControlMode

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

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

- C:/git/138-882-00_optoMDC/src/main/python/optoMDC/registers/mre3_registers.py