pvblocks 0.1.6__py3-none-any.whl

pvblocks/__init__.py

@@ -0,0 +1,2 @@
+VERSION = '0.1.6'
+__version__ = VERSION

pvblocks/__main__.py

@@ -0,0 +1,6 @@
+import os
+import argparse
+
+from datetime import datetime
+
+from . import VERSION

pvblocks/constants.py

@@ -0,0 +1,49 @@
+IDLE_COMMAND = 0
+BLINK_COMMAND = 1
+VOLTAGE_COMMAND = 2
+MPP_COMMAND = 3
+READ_COMMAND = 4
+CURVE_COMMAND = 5
+TRANSFER_CURVE_COMMAND = 6
+EXTERNAL_MPP_COMMAND = 7
+TRIGGERED_CURVE_COMMAND = 8
+GET_STATUS = 13
+WRITE_EEPROM_COMMAND = 14
+SET_TRIGGER_COMMAND = 15
+READ_EEPROM_COMMAND = 16
+UPDATE_CONFIG_COMMAND = 17
+GET_CONFIG_COMMAND = 18
+START_FIRMWARE_UPDATE = 19
+ENABLE_FAST_COMMUNICATIONS = 20
+DISABLE_BROADCAST = 21
+SELF_RESET_CMD = 24
+TRIGGERED_READ_COMMAND = 50
+ALIVE = 100
+LIST_MODULES = 101
+OPEN_MODULE = 106
+CLOSE_MODULE = 107
+RESET_MODULE = 108
+RESET_CONTROLLER = 109
+TRIGGER_ALL = 110
+BROADCAST_THRESHOLD_EXCEEDED = 111
+ALIVE_RR1701 = 200
+CURVE_RUNNING = 250
+RR1700 = 0
+RR1701 = 1
+
+
+IVMPP_READ_IVPOINT = 20
+IVMPP_APPLY_STATE = 21
+PV_IRR_READ_IRRADIANCES = 30
+
+VOC = 0
+ISC = 1
+MPP = 2
+VOLTAGE_BIAS = 3
+
+ISC_TO_VOC = 0
+SWEEP_ISC_TO_VOC = 0
+SWEEP_VOC_TO_ISC = 1
+EXTENT_CURVE_DELAY = 2
+SWEEP_VOC_ISC_VOC = 4
+SWEEP_ISC_VOC_ISC = 8

pvblocks/exceptions.py

@@ -0,0 +1,36 @@
+class NoResponseException(Exception):
+    '''No response from system.'''
+    def __str__(self):
+        return self.__doc__
+
+class UnexpectedResponseException(Exception):
+    '''Unexpected response from system.'''
+    def __str__(self):
+        return self.__doc__
+
+class NoReadDataImplementedException(Exception):
+    '''No read_data implemented for this blocktype.'''
+
+    def __str__(self):
+        return self.__doc__
+
+
+class CannotOpenBlockException(Exception):
+    '''Cannot open PVBlock.'''
+
+    def __str__(self):
+        return self.__doc__
+
+
+class MethodNotSupportedException(Exception):
+    '''Method not supported for PVBlock.'''
+
+    def __str__(self):
+        return self.__doc__
+
+
+class PvBlocksIsNoneException(Exception):
+    '''PVBlock is None'''
+
+    def __str__(self):
+        return self.__doc__

pvblocks/pvblocks_api.py

@@ -0,0 +1,351 @@
+from . import VERSION
+from . import exceptions
+from . import constants
+
+import requests
+
+EndOfLine = '\r\n'
+
+def show_version():
+    return VERSION
+
+def get_channel_number(usbNr, boardNr, channelNr):
+    return channelNr + 1  +  (boardNr*8) + usbNr*32
+
+def extract_hex_values(guid_string):
+    xx = guid_string[6:8]
+    yy = guid_string[21:23]
+    return int(xx, 16), int(yy, 16)
+
+
+# (usb nr, board nr, channel nr), with slotnr = None for a temperature sensor
+def GetPosition(guid_string):
+    (BlockNr, UsbNr) = extract_hex_values(guid_string)
+
+    if BlockNr > 100:
+        return (UsbNr, int((BlockNr -101)/8), (BlockNr -101)%8)
+
+    return (UsbNr, BlockNr-64, None)
+
+def create_rr1741_sensors(input_array):
+    result = []
+    for md in input_array:
+        sens = md['sensors'][0]
+        result.append({'id': sens['id'], 'name': sens['name'], 'description': sens['description']})
+    return result
+
+def create_rr1727_sensors(input_array):
+    result = []
+    for sens in input_array:
+        result.append({'id': sens['id'], 'name': sens['name'], 'description': sens['description']})
+    return result
+
+
+class PvBlocksApi(object):
+    TYPES = {
+        20: 'IV/MPP IV-Curve control and measure PvBlock',
+        27: 'IV/MPP IV-Curve control and measure PvBlock',
+        30: 'PV-IRR 4x analog voltage readout block',
+        40: 'PV-TEMP 4x Pt100 readout block',
+        41: 'PV-TEMP 2x Thermocouple T readout block',
+        50: 'PV-MOD digital modbus module'
+    }
+
+    def __init__(self, host, api_key):
+        self.PVBlocksUrl = 'http://' + host
+        self.APIkey = api_key
+        self.Blocks = []
+        self.PvBaseSystemType = constants.RR1700
+        self.token = ''
+
+
+    def _url(self, path):
+        return self.PVBlocksUrl + '/v1' + path
+
+    def get_token(self):
+        resp = requests.post(self._url('/authentication/Login'), json={'key': self.APIkey})
+        if resp.status_code != 200:
+            # This means something went wrong.
+            raise Exception('POST /authentication/Login {}'.format(resp.status_code))
+        else:
+            return resp.json()['bearer']
+
+    def get(self, endpoint, expected_response_code=200, json_response=True):
+        resp = requests.get(self._url(endpoint), headers={'Authorization': 'Bearer ' + self.token})
+        if resp.status_code != expected_response_code:
+            self.token = self.get_token()
+            resp = requests.get(
+                self._url(endpoint), headers={'Authorization': 'Bearer ' + self.token})
+        if resp.status_code != expected_response_code:
+            raise Exception('GET /' + endpoint + '{}'.format(resp.status_code))
+        else:
+            if json_response:
+                return resp.json()
+            else:
+                pass
+    def post(self, endpoint, payload, expected_response_code=201, json_response=True):
+        resp = requests.post(self._url(endpoint), headers={'Authorization': 'Bearer ' + self.token}, json=payload)
+        if resp.status_code != expected_response_code:
+            self.token = self.get_token()
+            resp = requests.post(
+                self._url(endpoint), headers={'Authorization': 'Bearer ' + self.token}, json=payload)
+        if resp.status_code != expected_response_code:
+            raise Exception('POST /' + endpoint + '{}'.format(resp.status_code))
+        else:
+            if json_response:
+                return resp.json()
+            else:
+                pass
+
+    def put(self, endpoint, payload, expected_response_code=204):
+        resp = requests.put(self._url(endpoint), headers={'Authorization': 'Bearer ' + self.token}, json=payload)
+        if resp.status_code != expected_response_code:
+            self.token = self.get_token()
+            resp = requests.put(
+                self._url(endpoint), headers={'Authorization': 'Bearer ' + self.token}, json=payload)
+        if resp.status_code != expected_response_code:
+            raise Exception('PUT /' + endpoint + '{}'.format(resp.status_code))
+
+
+    def delete(self, endpoint, expected_response_code=204):
+        resp = requests.delete(self._url(endpoint), headers={'Authorization': 'Bearer ' + self.token})
+        if resp.status_code != expected_response_code:
+            self.token = self.get_token()
+            resp = requests.delete(
+                self._url(endpoint), headers={'Authorization': 'Bearer ' + self.token})
+        if resp.status_code != expected_response_code:
+            raise Exception('DEL /' + endpoint + '{}'.format(resp.status_code))
+
+
+
+    def get_api_version(self):
+        resp = requests.get(self._url('/info'))
+        if resp.status_code != 200:
+            # This means something went wrong.
+            raise Exception('GET /info {}'.format(resp.status_code))
+        else:
+            return resp.json()['version']
+
+    def Online(self):
+        return self.get_api_version() == 'v1'
+
+    def Init(self):
+        if self.Online():
+            count = self.scan_blocks()
+            print('Scanned {} blocks'.format(count))
+        else:
+            print('System not online')
+
+    def get_pvdevices(self):
+        endpoint = '/PvDevice'
+        return self.get(endpoint)
+
+    def create_pvdevice(self, label):
+        endpoint = '/PvDevice'
+        payload = {
+            "Name": label,
+            "Serial": "",
+            "Manufacturer": "",
+            "ManufacturerCode": "",
+            "Material": "",
+            "IsBiFacial": False,
+            "Voc": 0,
+            "Isc": 0,
+            "Power": 0,
+            "Alpha": 0,
+            "Beta": 0,
+            "TemperatureCoefficient": 0,
+            "Area": 0,
+            "CellCount": 0,
+            "StringCount": 0,
+            "TemperatureId": 0,
+            "IrradianceId": 0
+        }
+        return self.post(endpoint, payload)
+
+    def delete_pvdevice(self, id):
+        endpoint = '/PvDevice/{}'.format(id)
+        self.delete(endpoint)
+
+    def get_pvblocks(self):
+        endpoint = '/Block'
+        return self.get(endpoint)
+
+    def list_all_unique_identifiers(self):
+        blocks = self.get_pvblocks()
+        result = []
+        for b in blocks:
+            result.append((b['uniqueIdentifier']))
+        return result
+
+    def scan_blocks(self):
+        blks = self.get_pvblocks()
+        module_count = len(blks)
+        self.Blocks = []
+        for b in blks:
+            (usb, board, channel) = GetPosition(b['uniqueIdentifier'])
+            if b['type'] == 'RR-1727':
+                sensors = create_rr1727_sensors(b['measurementDevices'][0]['sensors'])
+            if b['type'] == 'RR-1741':
+                sensors = create_rr1741_sensors(b['measurementDevices'])
+
+            self.Blocks.append({ "label": b["label"], "id": b["id"],"guid": b['uniqueIdentifier'],
+                                "usbNr": usb, "boardNr": board, "channelNr": channel,
+                                             "type": b['type'], "sensors": sensors, 'commands': b['availableCommands']})
+        return module_count
+
+    def reset_block(self, guid):
+        endpoint = '/Hardware/%s/reset' % (guid)
+        return self.get(endpoint, expected_response_code=204, json_response=False)
+
+    def write_block_label(self, id, label):
+        endpoint = '/Block/Label/{}'.format(id)
+        payload = {'position': 0, 'label': label}
+        return self.post(endpoint, payload, expected_response_code=200)
+
+
+    def write_rr1727_default_sweep(self, id, points, integration_cycles, sweepType ):
+        endpoint = '/Command/updateIvCurveParameters/%d' % (id)
+        payload = {'points': points, 'delay': integration_cycles, 'sweepstyle': sweepType}
+        self.post(endpoint, payload, expected_response_code=200, json_response=False)
+
+
+    def read_rr1727_calibration_values(self, guid):
+        endpoint = '/Hardware/%s/sendCommand' % (guid)
+        payload = {'CommandName': 'ReadFloatEeprom', 'Parameters': {'count': 4, 'address': 4}}
+        return self.post(endpoint, payload, expected_response_code=200)['1']
+
+    def write_rr1727_calibration_values(self, guid, A, B, C, D):
+        endpoint = '/Hardware/%s/sendCommand' % (guid)
+        payload = {'CommandName': 'WriteFloatEeprom', 'Parameters': {'flt': A, 'address': 4}}
+        self.post(endpoint, payload, expected_response_code=200, json_response=False)
+        payload = {'CommandName': 'WriteFloatEeprom', 'Parameters': {'flt': B, 'address': 8}}
+        self.post(endpoint, payload, expected_response_code=200, json_response=False)
+        payload = {'CommandName': 'WriteFloatEeprom', 'Parameters': {'flt': C, 'address': 12}}
+        self.post(endpoint, payload, expected_response_code=200, json_response=False)
+        payload = {'CommandName': 'WriteFloatEeprom', 'Parameters': {'flt': D, 'address': 16}}
+        self.post(endpoint, payload, expected_response_code=200, json_response=False)
+        self.reset_block(guid)
+
+    def get_schedules(self):
+        endpoint = '/Pipeline'
+        return self.get(endpoint)
+
+    def create_schedule(self, interval='* * * * *', daylightOnly=False):
+        if interval == 1:
+            crontab = '* * * * *'
+        else:
+            crontab ='*/%d * * * *' % (interval)
+
+        description = 'Execute every %d minutes' % (interval)
+        if daylightOnly:
+            description += ' during daylight'
+
+        endpoint = "/Pipeline"
+        payload = {'description': description,  'daylightOnly': daylightOnly,  'cronTabs': [crontab]}
+        return self.post(endpoint, payload, expected_response_code=201)
+
+    def delete_schedule(self, id):
+        endpoint = '/Pipeline/{}'.format(id)
+        self.delete(endpoint)
+
+    def enable_scheduler(self):
+        endpoint = '/Pipeline/enable'
+        self.post(endpoint, {}, expected_response_code=204, json_response=False)
+
+    def disable_scheduler(self):
+        endpoint = '/Pipeline/disable'
+        self.post(endpoint, {}, expected_response_code=204, json_response=False)
+
+    def update_sensor_description(self, id, label):
+        endpoint = '/Sensor/{}'.format(id)
+        original = self.get(endpoint)
+        sensor = {'description': label,
+                  'enabled': original['enabled'],
+                  'unit': original['unit'],
+                  'calibration': original['calibration'],
+                  'options': original['options'],
+                  'name': original['name'] }
+        self.put(endpoint, sensor)
+
+
+    def attach_sensor_to_pvdevice(self, sensor_id, pvdevice_id):
+        endpoint = '/Sensor/%d/attach/%d' % (sensor_id, pvdevice_id)
+        payload = {}
+        self.post(endpoint, payload, expected_response_code=201)
+
+    def add_command_to_schedule(self, schedule_id, blockId, command):
+        endpoint = '/Pipeline/%d/command' % (schedule_id)
+        payload = { 'pvBlockId': blockId,  'commandName': command['name'], 'parameters': command['defaultParameters'], 'withTrigger': command['defaultWithTrigger']}
+        self.post(endpoint, payload, expected_response_code=201)
+
+    # State definitions:
+    # Voc = 0,
+    # Isc = 1,
+    # Mpp = 2,
+    # Vbias = 3
+
+    def write_rr1727_state(self, guid, state, voltageBias=0, store=True):
+        endpoint = '/Hardware/%s/sendCommand' % (guid)
+        payload = {'CommandName': 'ApplyState', 'Parameters': {'state': state, 'voltageBias': voltageBias}}
+        self.post(endpoint, payload, expected_response_code=200)
+        if store:
+            endpoint = '/Hardware/%s/storeIvMppState' % (guid)
+            payload = {'guid': guid, 'state': state, 'vbias': voltageBias}
+            self.put(endpoint, payload, expected_response_code=201)
+
+    def ApplyVoc(self, guid):
+        self.write_rr1727_state(guid, 0, store=False)
+
+    def ApplyIsc(self, guid):
+        self.write_rr1727_state(guid, 1, store=False)
+
+    def write_rr1727_integration_time(self, guid, integration_time):
+        if integration_time not in [1,4,9,15]:
+            raise ValueError("Integration time must be in [1,4,9,15]")
+
+        endpoint = '/Hardware/%s/sendCommand' % (guid)
+        payload = {'CommandName': 'WriteEeprom', 'Parameters': {'data': str(integration_time), 'address': 116}}
+        self.post(endpoint, payload, expected_response_code=200)
+        self.reset_block(guid)
+
+    def read_rr1727_integration_time(self, guid):
+        endpoint = '/Hardware/%s/sendCommand' % (guid)
+        payload = {'CommandName': 'ReadEeprom', 'Parameters': {'length': 1, 'address': 116}}
+        return self.post(endpoint, payload, expected_response_code=200)['1'][0]
+
+    def read_rr1727_mpp_values(self, guid):
+        endpoint = '/Hardware/%s/sendCommand' % (guid)
+        payload = {'CommandName': 'ReadFloatEeprom', 'Parameters': {'count': 4, 'address': 64}}
+        return self.post(endpoint, payload, expected_response_code=200)['1']
+
+    def write_rr1727_mpp_values(self, guid, p1, p2, p3, p4):
+        endpoint = '/Hardware/%s/sendCommand' % (guid)
+        payload = {'CommandName': 'WriteFloatEeprom', 'Parameters': {'flt': p1, 'address': 64}}
+        self.post(endpoint, payload, expected_response_code=200, json_response=False)
+        payload = {'CommandName': 'WriteFloatEeprom', 'Parameters': {'flt': p2, 'address': 68}}
+        self.post(endpoint, payload, expected_response_code=200, json_response=False)
+        payload = {'CommandName': 'WriteFloatEeprom', 'Parameters': {'flt': p3, 'address': 72}}
+        self.post(endpoint, payload, expected_response_code=200, json_response=False)
+        payload = {'CommandName': 'WriteFloatEeprom', 'Parameters': {'flt': p4, 'address': 76}}
+        self.post(endpoint, payload, expected_response_code=200, json_response=False)
+        endpoint = '/Hardware/%s/refresh-eeprom' % (guid)
+        self.get(endpoint, expected_response_code=204, json_response=False)
+
+    def read_rr1741_temperatures(self, guid):
+        endpoint = '/Hardware/%s/sendCommand' % (guid)
+        payload = {'CommandName': 'GetTemperatures', 'Parameters': {'direct': True}}
+        result = self.post(endpoint, payload, expected_response_code=200)
+        return [result['1']['temperature'], result['2']['temperature']]
+
+    def read_rr1727_ivpoint(self, guid):
+        endpoint = '/Hardware/%s/sendCommand' % (guid)
+        payload = {'CommandName': 'MeasureDirectIvPoint'}
+        result = self.post(endpoint, payload, expected_response_code=200)
+        return [result['1']['ivpoint']['i'], result['1']['ivpoint']['v']]
+
+    def sweep_rr1727_ivcurve(self, guid, points, integration_cycles, sweepType):
+        endpoint = '/Hardware/%s/sendCommand' % (guid)
+        payload = {'CommandName': 'StartIvCurve', 'Parameters': {'points': points, 'delay': integration_cycles, 'sweepstyle': sweepType}}
+        result = self.post(endpoint, payload, expected_response_code=200)
+        return {'Voltages': result['1']['Voltages'], 'Currents': result['1']['Currents']}

pvblocks/pvblocks_system.py

@@ -0,0 +1,540 @@
+from . import VERSION
+from . import exceptions
+from . import constants
+import serial
+import uuid
+import struct
+from time import sleep
+from enum import IntEnum
+
+
+
+def show_version():
+    return VERSION
+
+
+def ReadSerial(ser):
+    out = []
+    while ser.inWaiting() > 0:
+        out.append(ser.read(1)[0])
+    return out
+
+
+class PvBlocks(object):
+    TYPES = {
+        20: 'IV/MPP IV-Curve control and measure PvBlock',
+        27: 'IV/MPP IV-Curve control and measure PvBlock',
+        30: 'PV-IRR 4x analog voltage readout block',
+        40: 'PV-TEMP 4x Pt100 readout block',
+        41: 'PV-TEMP 2x Thermocouple T readout block',
+        50: 'PV-MOD digital modbus module'
+    }
+
+    def __init__(self, serialport):
+        # type: (UART_Adapter) -> None
+        self.uart = serial.Serial(serialport,
+                                  baudrate=115200,
+                                  bytesize=serial.EIGHTBITS,
+                                  parity=serial.PARITY_NONE,
+                                  stopbits=serial.STOPBITS_ONE,
+                                  timeout=1)
+        self.Blocks = []
+        self.IvMppBlocks = []
+        self.PvIrrBlocks = []
+        self.PvBaseSystemType = constants.RR1700
+
+    def init_system(self):
+        self.uart.write(serial.to_bytes([1, constants.ALIVE]))
+        sleep(0.5)
+        bts = ReadSerial(self.uart)
+        if len(bts) != 2:
+            raise exceptions.NoResponseException()
+
+        if bts[1] == constants.ALIVE_RR1701:
+            self.PvBaseSystemType = constants.RR1701
+
+        return bts[0] == 3 and bts[1] == constants.ALIVE or bts[1] == constants.ALIVE_RR1701
+
+
+    def close_system(self):
+        self.uart.close()
+
+
+    def scan_blocks(self):
+        self.uart.write(serial.to_bytes([1, constants.LIST_MODULES]))
+        sleep(2)
+        bts = ReadSerial(self.uart)
+
+        if (bts[0] != 3) or (bts[1] != constants.LIST_MODULES):
+            raise exceptions.UnexpectedResponseException()
+
+        module_count = bts[3]
+        self.Blocks = []
+        self.IvMppBlocks = []
+        self.PvIrrBlocks = []
+        for index in range(module_count):
+            match bts[(index * 9) + 4 + 8]:
+                case 20:
+                    blck = IvMpp(bts[(index * 9) + 4: (index * 9) + 13], self.uart)
+                    self.IvMppBlocks.append(blck)
+                case 27:
+                    blck = IvMpp27(bts[(index * 9) + 4: (index * 9) + 13], self.uart)
+                    self.IvMppBlocks.append(blck)
+                case 30:
+                    blck = PvIrr(bts[(index * 9) + 4: (index * 9) + 13], self.uart)
+                    self.PvIrrBlocks.append(blck)
+                case _:
+                    blck = PvBlock(bts[(index * 9) + 4: (index * 9) + 13], self.uart)
+                    self.Blocks.append(blck)
+
+
+        return module_count > 0
+
+    def reset_controller(self):
+        if not self.uart.is_open:
+            self.uart.open()
+
+        self.uart.write(serial.to_bytes([1, constants.RESET_CONTROLLER]))
+        sleep(3)
+
+
+
+
+class PvBlock(object):
+    def __init__(self, bytes, uart):
+        self.bytes = bytes[0:8]
+        id = int.from_bytes(bytearray(self.bytes), 'little')
+        self.Guid = uuid.UUID(int=id)
+        self.Type = bytes[8]
+        self.uart = uart
+        self.node = 2
+
+
+    def reset_block(self):
+        self.uart.write(serial.to_bytes([1,
+                                         constants.RESET_MODULE,
+                                         self.bytes[0],
+                                         self.bytes[1],
+                                         self.bytes[2],
+                                         self.bytes[3],
+                                         self.bytes[4],
+                                         self.bytes[5],
+                                         self.bytes[6],
+                                         self.bytes[7]]))
+        sleep(0.5)
+
+
+    def open(self):
+        self.uart.write(serial.to_bytes([1,
+                                         constants.OPEN_MODULE,
+                                         0,
+                                         self.bytes[0],
+                                         self.bytes[1],
+                                         self.bytes[2],
+                                         self.bytes[3],
+                                         self.bytes[4],
+                                         self.bytes[5],
+                                         self.bytes[6],
+                                         self.bytes[7]]))
+        sleep(0.5)
+        bts = ReadSerial(self.uart)
+
+        return len(bts) == 3
+
+    def close(self):
+        self.uart.write(serial.to_bytes([1,
+                                         constants.CLOSE_MODULE,
+                                         self.bytes[0],
+                                         self.bytes[1],
+                                         self.bytes[2],
+                                         self.bytes[3],
+                                         self.bytes[4],
+                                         self.bytes[5],
+                                         self.bytes[6],
+                                         self.bytes[7]]))
+        sleep(0.5)
+        bts = ReadSerial(self.uart)
+
+        return len(bts) == 3
+
+
+
+
+
+    def read_statusbyte(self):
+        self.open()
+        self.uart.write(serial.to_bytes([self.node, constants.GET_STATUS]))
+        sleep(0.5)
+        bts = ReadSerial(self.uart)
+        self.close()
+        if len(bts) < 10:
+            raise exceptions.UnexpectedResponseException()
+        return StatusByte(bts)
+
+    def get_info(self):
+        status = self.read_statusbyte()
+        d = {'firmware': status.firmware, 'hardware': status.hardware}
+        return d
+
+
+
+
+class IvMpp(PvBlock):
+    def read_ivpoint(self):
+
+        self.open()
+        self.uart.write(serial.to_bytes([2, constants.READ_COMMAND]))
+        sleep(0.5)
+        bts = ReadSerial(self.uart)
+        self.close()
+        if len(bts) < 15:
+            raise exceptions.UnexpectedResponseException()
+
+        if bts[2] != 12:
+            raise exceptions.UnexpectedResponseException()
+
+        r1 = int.from_bytes(bts[3:7], "little") / 10000.0
+        r2 = int.from_bytes(bts[7:11], "little") / 100000.0
+        ivpoint = IvPoint(r1, r2)
+
+        return ivpoint
+
+    def ApplyVoc(self):
+        self.open()
+        self.uart.write(serial.to_bytes([2, constants.IDLE_COMMAND]))
+        sleep(0.5)
+        self.close()
+
+
+    def ApplyMpp(self):
+        self.open()
+        self.uart.write(serial.to_bytes([2, constants.MPP_COMMAND]))
+        sleep(0.5)
+        self.close()
+
+    def ApplyIsc(self):
+        voltage = 0.0;
+        self.open()
+        bytes = list(((int)(1000 * voltage)).to_bytes(4, "little"))
+        self.uart.write(serial.to_bytes([2, constants.VOLTAGE_COMMAND, bytes[0], bytes[1], bytes[2], bytes[3]]))
+        sleep(0.5)
+        self.close()
+
+    def ApplyVoltageBias(self, voltage):
+        self.open()
+        bytes = list(((int)(1000 * voltage)).to_bytes(4, "little"))
+        self.uart.write(
+            serial.to_bytes([2, constants.VOLTAGE_COMMAND, bytes[0], bytes[1], bytes[2], bytes[3]]))
+        sleep(0.5)
+        self.close()
+
+    def measure_ivcurve(self, points, delay_ms, sweepstyle):
+        self.open()
+
+        self.uart.write(
+            serial.to_bytes([2, constants.SET_TRIGGER_COMMAND, 0]))
+
+        sleep(0.5)
+
+        self.uart.write(
+            serial.to_bytes([2, constants.CURVE_COMMAND, points, delay_ms, 0, 0, 0, 0, sweepstyle]))
+
+        while self.uart.inWaiting() != 3:
+            sleep(0.01)
+
+        bts = ReadSerial(self.uart)
+
+        status = self.read_statusbyte()
+        while status.mode == 5:
+            sleep(0.5)
+            status = self.read_statusbyte()
+
+        self.close()
+        points_measured = status.statusbytes[0]
+        curve = self.transfer_curve(points_measured)
+
+        return curve
+
+    def transfer_curve(self, points):
+        self.open()
+        self.uart.write(serial.to_bytes([2, constants.TRANSFER_CURVE_COMMAND]))
+        sleep(0.5)
+        availablebytes = 8 + (points * 8) + 1
+        toread = self.uart.inWaiting()
+        while toread != availablebytes:
+            toread = self.uart.inWaiting()
+            print(toread)
+            sleep(0.1)
+        bts = ReadSerial(self.uart)
+        self.close()
+
+        voltages = []
+        currents = []
+
+        for i in range(1, int((availablebytes - 1)/8)):
+            index = (i * 8) + 1
+            voltages.append(int.from_bytes(bts[index:(index+4)], "little") / 10000.0)
+            index = index + 4
+            currents.append(int.from_bytes(bts[index:(index+4)], "little") / 100000.0)
+
+        return {'voltages': voltages, 'currents': currents}
+
+    def read_calibration(self):
+        c = {'A': 0.0, 'B': 0.0, 'C': 0.0, 'D': 0.0}
+        bts = self.read_eeprom(4, 16)
+        c['A'] = struct.unpack('<f', bytearray(bts[0:4]))
+        c['B'] = struct.unpack('<f', bytearray(bts[4:8]))
+        c['C'] = struct.unpack('<f', bytearray(bts[8:12]))
+        c['D'] = struct.unpack('<f', bytearray(bts[12:16]))
+
+        return c
+
+    def read_eeprom(self, address, length):
+        bts = list(address.to_bytes(2, 'little'))
+        self.open()
+        self.uart.write(
+            serial.to_bytes([2, constants.READ_EEPROM_COMMAND, length, bts[0], bts[1]]))
+
+        while self.uart.inWaiting() != length + 3:
+            sleep(0.01)
+
+        bts = ReadSerial(self.uart)
+        self.close()
+        return bts[3:]
+
+    def write_voltage_calibration(self, A, B):
+        ba = list(bytearray(struct.pack("<f", A)))
+        self.write_eeprom(ba, 4)
+        ba = list(bytearray(struct.pack("<f", B)))
+        self.write_eeprom(ba, 8)
+        self.reset_block()
+        sleep(3)
+
+
+    def write_current_calibration(self,C, D):
+        ba = list(bytearray(struct.pack("<f", C)))
+        self.write_eeprom(ba, 12)
+        ba = list(bytearray(struct.pack("<f", D)))
+        self.write_eeprom(ba, 16)
+        self.reset_block()
+        sleep(3)
+
+
+    def write_eeprom(self, data, address):
+        bts = list(address.to_bytes(self.node, 'little'))
+        tx = [self.node, constants.WRITE_EEPROM_COMMAND, len(data), bts[0], bts[1]]
+
+        self.open()
+        self.uart.write(serial.to_bytes(tx + data))
+        self.close()
+        sleep(0.5)
+
+
+class IvMpp27(PvBlock):
+    def __init__(self, bytes, uart):
+        super().__init__(bytes, uart)
+        self.node = bytes[0]
+
+    def reset(self):
+        self.open()
+        self.uart.write(serial.to_bytes([self.node, constants.SELF_RESET_CMD]))
+        sleep(0.5)
+        self.close()
+
+    def read_ivpoint(self):
+
+        self.open()
+        self.uart.write(serial.to_bytes([self.node, constants.READ_COMMAND]))
+        sleep(0.5)
+        bts = ReadSerial(self.uart)
+        self.close()
+        if len(bts) < 15:
+            raise exceptions.UnexpectedResponseException()
+
+        if bts[2] != 12:
+            raise exceptions.UnexpectedResponseException()
+
+        r1 = int.from_bytes(bts[3:7], "little") / 10000.0
+        r2 = int.from_bytes(bts[7:11], "little") / 100000.0
+        ivpoint = IvPoint(r1, r2)
+
+        return ivpoint
+
+    def ApplyVoc(self):
+        self.open()
+        self.uart.write(serial.to_bytes([self.node, constants.IDLE_COMMAND]))
+        sleep(0.5)
+        self.close()
+
+
+    def ApplyMpp(self):
+        self.open()
+        self.uart.write(serial.to_bytes([self.node, constants.MPP_COMMAND]))
+        sleep(0.5)
+        self.close()
+
+    def ApplyIsc(self):
+        voltage = 0.0;
+        self.open()
+        bytes = list(((int)(1000 * voltage)).to_bytes(4, "little"))
+        self.uart.write(serial.to_bytes([self.node, constants.VOLTAGE_COMMAND, bytes[0], bytes[1], bytes[2], bytes[3]]))
+        sleep(0.5)
+        self.close()
+
+    def ApplyVoltageBias(self, voltage):
+        self.open()
+        bytes = list(((int)(1000 * voltage)).to_bytes(4, "little"))
+        self.uart.write(
+            serial.to_bytes([self.node, constants.VOLTAGE_COMMAND, bytes[0], bytes[1], bytes[2], bytes[3]]))
+        sleep(0.5)
+        self.close()
+
+    def measure_ivcurve(self, points, delay_ms, sweepstyle):
+        self.open()
+
+        self.uart.write(
+            serial.to_bytes([self.node, constants.SET_TRIGGER_COMMAND, 0]))
+
+        sleep(0.5)
+
+        self.uart.write(
+            serial.to_bytes([self.node, constants.CURVE_COMMAND, points, delay_ms, 0, 0, 0, 0, sweepstyle]))
+
+        while self.uart.inWaiting() != 3:
+            sleep(0.01)
+
+        bts = ReadSerial(self.uart)
+
+        status = self.read_statusbyte()
+        while status.mode == 5:
+            sleep(0.5)
+            status = self.read_statusbyte()
+
+        self.close()
+        points_measured = status.statusbytes[0]
+        curve = self.transfer_curve(points_measured)
+
+        return curve
+
+    def transfer_curve(self, points):
+        self.open()
+        self.uart.write(serial.to_bytes([self.node, constants.TRANSFER_CURVE_COMMAND]))
+        sleep(0.5)
+        availablebytes = 8 + (points * 8) + 1
+        toread = self.uart.inWaiting()
+        while toread != availablebytes:
+            toread = self.uart.inWaiting()
+            print(toread)
+            sleep(0.1)
+        bts = ReadSerial(self.uart)
+        self.close()
+
+        voltages = []
+        currents = []
+
+        for i in range(1, int((availablebytes - 1)/8)):
+            index = (i * 8) + 1
+            voltages.append(int.from_bytes(bts[index:(index+4)], "little") / 10000.0)
+            index = index + 4
+            currents.append(int.from_bytes(bts[index:(index+4)], "little") / 100000.0)
+
+        return {'voltages': voltages, 'currents': currents}
+
+    def read_calibration(self):
+        c = {'A': 0.0, 'B': 0.0, 'C': 0.0, 'D': 0.0}
+        bts = self.read_eeprom(4, 16)
+
+        c['A'] = struct.unpack('<f', bytearray(bts[0:4]))
+        c['B'] = struct.unpack('<f', bytearray(bts[4:8]))
+        c['C'] = struct.unpack('<f', bytearray(bts[8:12]))
+        c['D'] = struct.unpack('<f', bytearray(bts[12:16]))
+
+        return c
+
+    def write_voltage_calibration(self, A, B):
+        ba = list(bytearray(struct.pack("<f", A)))
+        self.write_eeprom(ba, 4)
+        ba = list(bytearray(struct.pack("<f", B)))
+        self.write_eeprom(ba, 8)
+        self.reset()
+        sleep(3)
+
+
+    def write_current_calibration(self,C, D):
+        ba = list(bytearray(struct.pack("<f", C)))
+        self.write_eeprom(ba, 12)
+        ba = list(bytearray(struct.pack("<f", D)))
+        self.write_eeprom(ba, 16)
+        self.reset()
+        sleep(3)
+
+    def read_eeprom(self, address, length):
+        bts = list(address.to_bytes(self.node, 'little'))
+        self.open()
+        self.uart.write(
+            serial.to_bytes([self.node, constants.READ_EEPROM_COMMAND, length, bts[0], bts[1]]))
+
+        while self.uart.inWaiting() != length + 3:
+            sleep(0.01)
+
+        bts = ReadSerial(self.uart)
+        self.close()
+        return bts[3:]
+
+    def write_eeprom(self, data, address):
+        bts = list(address.to_bytes(self.node, 'little'))
+        tx = [self.node, constants.WRITE_EEPROM_COMMAND, len(data), bts[0], bts[1]]
+
+        self.open()
+        self.uart.write(serial.to_bytes(tx + data))
+        self.close()
+        sleep(0.5)
+
+
+
+
+
+class PvIrr(PvBlock):
+
+    def ReadIrradiances(self):
+        self.open()
+        self.uart.write(serial.to_bytes([2, constants.READ_COMMAND]))
+        sleep(0.5)
+        bts = ReadSerial(self.uart)
+        if len(bts) < 10:
+            raise exceptions.UnexpectedResponseException()
+
+        irradiances = []
+
+        r1 = int.from_bytes(bts[3:7], "little") / 1000.0
+        r2 = int.from_bytes(bts[7:11], "little") / 1000.0
+        irradiances.append(r1)
+        irradiances.append(r2)
+        if bts[2] == 16:
+            r3 = int.from_bytes(bts[11:15], "little") / 1000.0
+            r4 = int.from_bytes(bts[15:19], "little") / 1000.0
+            irradiances.append(r3)
+            irradiances.append(r4)
+
+        self.close()
+        return irradiances
+
+class StatusByte(object):
+    def __init__(self, bytes):
+        self.blocktype = bytes[2]
+        self.token = bytes[3]
+        self.mode = bytes[4]
+        self.statusbytes = bytes[5:]
+        self.firmware = bytes[9]
+        self.hardware = bytes[8]
+
+
+class IvPoint(object):
+    def __init__(self, voltage, current):
+        self.voltage = voltage
+        self.current = current
+        self.power = voltage * current
+
+    def __str__(self):
+        return "(%f, %f)" % (self.voltage, self.current)
+

pvblocks-0.1.6.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: pvblocks
+Version: 0.1.6
+Summary: Python package to directly control pvblocks modules
+Author-email: Erik Haverkamp <erik@rera.nl>
+Project-URL: Homepage, https://github.com/rerasolutions/pvblocks-python
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+### pvblocks
+
+Package to control pvblocks modules directly
+
+requires packages:
+
+pyserial

pvblocks-0.1.6.dist-info/RECORD

@@ -0,0 +1,13 @@
+test.py,sha256=HEBnuUicKLXo0hPGxfWnqHrRBd4EGFpRdnY7hAZQ9Jw,1576
+test_api.py,sha256=3LTVZCHltluplbRMYdgIU3NBaq13rc9_-mCJbD_91bE,5747
+pvblocks/__init__.py,sha256=deDwZUUNy-NL9BMy8q5Yj1y9Wsp8t_Y_IQ452_W7z_c,42
+pvblocks/__main__.py,sha256=fhvwtf6NzUeUsjP_ARtvxcmYjAvfwqz9_K1bHFwEjUg,84
+pvblocks/constants.py,sha256=E7LsCFWXIRHceIMWbGrGgE0fQqMnKZySIp_RtthU-xM,977
+pvblocks/exceptions.py,sha256=we35JF-svaCDAFYqKFlDCp7ZwbCU0FQe7nksKpUfPnQ,850
+pvblocks/pvblocks_api.py,sha256=XHfmDOrfPoLO05emOmKcTND4fBXy0tyIGc0NPV2eYKM,15113
+pvblocks/pvblocks_system.py,sha256=-CarH4lrseNLvAqgUpWsug6WpAvQ3E8JPVDr2JPOq2M,17076
+pvblocks-0.1.6.dist-info/licenses/LICENSE,sha256=eLQBGuCvsZgLd0xvjckcr-aG-1UB7JzD5VE52GsskPU,1091
+pvblocks-0.1.6.dist-info/METADATA,sha256=-PMGbegokiqmAwPAkdCQGCTl6uWIkCKuYztEUEXMCyQ,593
+pvblocks-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pvblocks-0.1.6.dist-info/top_level.txt,sha256=Y8qcy__xcs9-JbDqIFw7FATtYTlhjqQ6rMpvigmGXAU,23
+pvblocks-0.1.6.dist-info/RECORD,,

pvblocks-0.1.6.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pvblocks-0.1.6.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 rerasolutions
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pvblocks-0.1.6.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+pvblocks
+test
+test_api

test.py

@@ -0,0 +1,69 @@
+from pvblocks import pvblocks_system
+from pvlib.ivtools.utils import rectify_iv_curve
+import numpy as np
+import time
+import sys
+
+print("PV-Blocks version: " + pvblocks_system.show_version())
+
+pvblocks = pvblocks_system.PvBlocks('COM8')
+import matplotlib.pyplot as plt
+
+if pvblocks.init_system():
+    print("init ok")
+else:
+    print("failed")
+
+print("scanning available blocks")
+
+start_time = time.time()
+if pvblocks.scan_blocks():
+    print("ok")
+else:
+    print("failed")
+end_time = time.time()
+elapsed_time = end_time - start_time
+print(f"Elapsed Time: {elapsed_time} seconds")
+
+
+iv_mpp = None
+
+for b in pvblocks.Blocks:
+    print(pvblocks_system.PvBlocks.TYPES[b.Type])
+
+for b in pvblocks.IvMppBlocks:
+    print(pvblocks_system.PvBlocks.TYPES[b.Type])
+
+for b in pvblocks.PvIrrBlocks:
+        print(pvblocks_system.PvBlocks.TYPES[b.Type])
+
+if len(pvblocks.IvMppBlocks) > 0:
+    iv_mpp = pvblocks.IvMppBlocks[0]
+
+#print(iv_mpp.get_info())
+ivpoint = iv_mpp.read_ivpoint()
+print(ivpoint)
+
+print(iv_mpp.read_calibration())
+
+
+
+#print('measure iv curve 200 points, 20ms')
+#start_time = time.time()
+#curve = iv_mpp.measure_ivcurve(200, 20, 0)
+#end_time = time.time()
+#elapsed_time = end_time - start_time
+#print(f"Elapsed Time: {elapsed_time} seconds")
+#(v, i) = rectify_iv_curve(curve['voltages'], curve['currents'])
+#p = v * i
+#voc = v[-1]
+#isc = i[0]
+#index_max = np.argmax(p)
+#impp = i[index_max]
+#vmpp = v[index_max]
+#pmax = p[index_max]
+#ff = pmax/(voc * isc)
+#pmax = p[index_max]
+
+
+pvblocks.close_system()

test_api.py

@@ -0,0 +1,148 @@
+
+host = ''
+apikey = ''
+
+from pvblocks import pvblocks_api
+from pvblocks import constants
+print(pvblocks_api.show_version())
+pvblocks = pvblocks_api.PvBlocksApi(host ,apikey)
+pvblocks.Init()
+
+def DeleteAllPvDevices():
+    for s in pvblocks.get_pvdevices():
+        pvblocks.delete_pvdevice(s['id'])
+
+def DeleteAllSchedules():
+    for s in pvblocks.get_schedules():
+        pvblocks.delete_schedule(s['id'])
+
+def RecreateSchedules():
+    TemperatureScheduleId = pvblocks.create_schedule(1, False)['id']
+    IvPointScheduleId = pvblocks.create_schedule(1, False)['id']
+    IvCurveScheduleId = pvblocks.create_schedule(5, False)['id']
+    return (TemperatureScheduleId, IvPointScheduleId, IvCurveScheduleId)
+
+def AssignTemperatureToSchedule(scheduleId):
+    for b in pvblocks.Blocks:
+        if b['type'] == "RR-1741":
+            pvblocks.add_command_to_schedule(scheduleId, b['id'], b['commands'][0])
+
+def AssignTIvCurveToSchedule(scheduleId):
+    for b in pvblocks.Blocks:
+        if b['type'] == "RR-1727":
+            for c in b['commands']:
+                if c['name'] == 'StartIvCurve':
+                    pvblocks.add_command_to_schedule(scheduleId, b['id'], c)
+
+def AssignTIvPointToSchedule(scheduleId):
+    for b in pvblocks.Blocks:
+        if b['type'] == "RR-1727":
+            for c in b['commands']:
+                if c['name'] == 'MeasureIvPoint':
+                    pvblocks.add_command_to_schedule(scheduleId, b['id'], c)
+
+def RecreateBlockLabels():
+    for b in pvblocks.Blocks:
+        if b['type'] == "RR-1727":
+            channel = pvblocks_api.get_channel_number(b['usbNr'], b['boardNr'], b['channelNr'])
+            label = "IVMPP-{}".format(channel)
+            print(label)
+            pvblocks.write_block_label(b['id'], label)
+            for s in b['sensors']:
+                if s['name'] == 'ivcurve':
+                    pvblocks.update_sensor_description(s['id'], "ivcurve-{}".format(channel))
+                else:
+                    pvblocks.update_sensor_description(s['id'], "ivpoint-{}".format(channel))
+
+        if b['type'] == "RR-1741":
+            location = 4* b['usbNr'] + b['boardNr'] + 1
+            label = "IVTEMP-{}".format(location)
+            print(label)
+            pvblocks.write_block_label(b['id'], label)
+            cnt = 1
+            for s in b['sensors']:
+                pvblocks.update_sensor_description(s['id'], "TC-{}".format(cnt))
+                cnt = cnt + 1
+
+
+def RecreatePvDevices():
+    for b in pvblocks.Blocks:
+        if b['type'] == "RR-1727":
+            channel = pvblocks_api.get_channel_number(b['usbNr'], b['boardNr'], b['channelNr'])
+            label = "PvDevice-{}".format(channel)
+            pvblocks.create_pvdevice(label)
+
+def RecreatePvDevicesAndAssign():
+    board_tc_sensor_ids = {}
+    for b in pvblocks.Blocks:
+        if b['type'] == "RR-1741":
+            board_tc_sensor_ids['boardNr{}'.format(b['boardNr'])] = [b['sensors'][0]['id'], b['sensors'][1]['id']]
+
+    for b in pvblocks.Blocks:
+        if b['type'] == "RR-1727":
+            channel = pvblocks_api.get_channel_number(b['usbNr'], b['boardNr'], b['channelNr'])
+            label = "PvDevice-{}".format(channel)
+            dev = pvblocks.create_pvdevice(label)
+            pvblocks.attach_sensor_to_pvdevice(b['sensors'][0]['id'] ,dev['id'])
+            pvblocks.attach_sensor_to_pvdevice(b['sensors'][1]['id'], dev['id'])
+            tc1_id = board_tc_sensor_ids['boardNr{}'.format(b['boardNr'])][0]
+            tc2_id = board_tc_sensor_ids['boardNr{}'.format(b['boardNr'])][1]
+            if b['channelNr'] < 4:
+                pvblocks.attach_sensor_to_pvdevice(tc1_id, dev['id'])
+            else:
+                pvblocks.attach_sensor_to_pvdevice(tc2_id, dev['id'])
+
+
+def SetStateForAllRr1727(state, voltageBias = 0, block_list = None):
+    if block_list is None:
+        block_list = pvblocks.Blocks
+
+    for b in block_list:
+        if b['type'] == "RR-1727":
+            pvblocks.write_rr1727_state(b['guid'], state, voltageBias)
+
+def SetSweepParametersForAllRr1727(points, integration_cycles, sweep_type, block_list = None):
+    if block_list is None:
+        block_list = pvblocks.Blocks
+
+    for b in block_list:
+        if b['type'] == "RR-1727":
+            pvblocks.write_rr1727_default_sweep(b['id'], points, integration_cycles, sweep_type)
+
+def SetCalibrationValuesForAllRr1727(A, B, C, D, block_list = None):
+    if block_list is None:
+        block_list = pvblocks.Blocks
+
+    for b in block_list:
+        print(b['label'])
+        if b['type'] == "RR-1727":
+            pvblocks.write_rr1727_calibration_values(b['guid'], A, B, C, D)
+
+def SetMppParametersForAllRr1727(p1, p2, p3, p4, block_list = None):
+    if block_list is None:
+        block_list = pvblocks.Blocks
+
+    for b in block_list:
+        print(b['label'])
+        if b['type'] == "RR-1727":
+            pvblocks.write_rr1727_mpp_values(b['guid'], p1, p2, p3, p4)
+
+def ShowBlocks(block_list = None):
+    if block_list is None:
+        block_list = pvblocks.Blocks
+
+    for b in block_list:
+        print(b['label'])
+
+# DeleteAllPvDevices()
+# RecreateBlockLabels()
+# RecreatePvDevicesAndAssign()
+# DeleteAllSchedules()
+# (TemperatureScheduleId, IvPointScheduleId, IvCurveScheduleId) = RecreateSchedules()
+# AssignTemperatureToSchedule(TemperatureScheduleId)
+# AssignTIvCurveToSchedule(IvCurveScheduleId)
+# AssignTIvPointToSchedule(IvPointScheduleId)
+# SetStateForAllRr1727(constants.MPP)
+# SetSweepParametersForAllRr1727(200, 4, constants.SWEEP_ISC_TO_VOC)
+# SetCalibrationValuesForAllRr1727(0.125, 0, 10, 0)
+# SetMppParametersForAllRr1727(0.75, 0, 0.01, 100)