pvblocks 0.1.0__tar.gz → 0.1.2__tar.gz

{pvblocks-0.1.0 → pvblocks-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pvblocks
-Version: 0.1.0
+Version: 0.1.2
 Summary: Python package to directly control pvblocks modules
 Author-email: Erik Haverkamp <erik@rera.nl>
 Project-URL: Homepage, https://github.com/rerasolutions/pvblocks-python

{pvblocks-0.1.0 → pvblocks-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pvblocks"
-version = "0.1.0"
+version = "0.1.2"
 authors = [
   { name="Erik Haverkamp", email="erik@rera.nl" },
 ]

pvblocks-0.1.2/src/pvblocks/__init__.py

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

pvblocks-0.1.2/src/pvblocks/constants.py

@@ -0,0 +1,43 @@
+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
+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
+CURVE_RUNNING = 250
+
+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_VOC_TO_ISC = 1
+EXTENT_CURVE_DELAY = 2
+SWEEP_VOC_ISC_VOC = 4
+SWEEP_ISC_VOC_ISC = 8

{pvblocks-0.1.0 → pvblocks-0.1.2}/src/pvblocks/pvblocks_system.py

@@ -41,12 +41,12 @@ class PvBlocks(object):
         self.PvIrrBlocks = []
 
     def init_system(self):
-        self.uart.write(serial.to_bytes([1, constants.Rr1700Command.Alive]))
+        self.uart.write(serial.to_bytes([1, constants.ALIVE]))
         sleep(0.5)
         bts = ReadSerial(self.uart)
         if len(bts) != 2:
             raise exceptions.NoResponseException()
-        return bts[0] == 3 and bts[1] == constants.Rr1700Command.Alive
+        return bts[0] == 3 and bts[1] == constants.ALIVE
 
 
     def close_system(self):
@@ -54,11 +54,11 @@ class PvBlocks(object):
 
 
     def scan_blocks(self):
-        self.uart.write(serial.to_bytes([1, constants.Rr1700Command.ListModules]))
+        self.uart.write(serial.to_bytes([1, constants.LIST_MODULES]))
         sleep(2)
         bts = ReadSerial(self.uart)
 
-        if (bts[0] != 3) or (bts[1] != constants.Rr1700Command.ListModules):
+        if (bts[0] != 3) or (bts[1] != constants.LIST_MODULES):
             raise exceptions.UnexpectedResponseException()
 
         module_count = bts[3]
@@ -84,37 +84,10 @@ class PvBlocks(object):
         if not self.uart.is_open:
             self.uart.open()
 
-        self.uart.write(serial.to_bytes([1, constants.Rr1700Command.ResetController]))
+        self.uart.write(serial.to_bytes([1, constants.RESET_CONTROLLER]))
         sleep(3)
 
 
-    def read_irradiances(self, pvblock):
-        if self.open_block(pvblock):
-            self.uart.write(serial.to_bytes([2, constants.Rr1700Command.ReadCommand]))
-            sleep(0.5)
-            bts = ReadSerial(self.uart)
-            if len(bts) < 10:
-                raise exceptions.UnexpectedResponseException()
-
-            r1 = int.from_bytes(bts[3:7], "little") / 1000.0
-            r2 = int.from_bytes(bts[7:11], "little") / 1000.0
-            if bts[2] == 16:
-                r3 = int.from_bytes(bts[11:15], "little") / 1000.0
-                r4 = int.from_bytes(bts[15:19], "little") / 1000.0
-                return r1, r2, r3, r4
-            else:
-                return r1, r2
-
-
-        else:
-            raise exceptions.CannotOpenBlockException()
-
-        return (0, 0, 0, 0)
-
-
-
-
-
 class PvBlock(object):
     def __init__(self, bytes, uart):
         self.bytes = bytes[0:8]
@@ -125,7 +98,7 @@ class PvBlock(object):
 
     def open(self):
         self.uart.write(serial.to_bytes([1,
-                                         constants.Rr1700Command.OpenModule,
+                                         constants.OPEN_MODULE,
                                          0,
                                          self.bytes[0],
                                          self.bytes[1],
@@ -142,7 +115,7 @@ class PvBlock(object):
 
     def close(self):
         self.uart.write(serial.to_bytes([1,
-                                         constants.Rr1700Command.CloseModule,
+                                         constants.CLOSE_MODULE,
                                          self.bytes[0],
                                          self.bytes[1],
                                          self.bytes[2],
@@ -159,7 +132,7 @@ class PvBlock(object):
 
     def read_statusbyte(self):
         self.open()
-        self.uart.write(serial.to_bytes([2, constants.Rr1700Command.GetStatus]))
+        self.uart.write(serial.to_bytes([2, constants.GET_STATUS]))
         sleep(0.5)
         bts = ReadSerial(self.uart)
         self.close()
@@ -177,7 +150,7 @@ class IvMpp(PvBlock):
     def read_ivpoint(self):
 
         self.open()
-        self.uart.write(serial.to_bytes([2, constants.Rr1700Command.ReadCommand]))
+        self.uart.write(serial.to_bytes([2, constants.READ_COMMAND]))
         sleep(0.5)
         bts = ReadSerial(self.uart)
         self.close()
@@ -195,14 +168,14 @@ class IvMpp(PvBlock):
 
     def ApplyVoc(self):
         self.open()
-        self.uart.write(serial.to_bytes([2, constants.Rr1700Command.IdleCommand]))
+        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.Rr1700Command.MppCommand]))
+        self.uart.write(serial.to_bytes([2, constants.MPP_COMMAND]))
         sleep(0.5)
         self.close()
 
@@ -210,7 +183,7 @@ class IvMpp(PvBlock):
         voltage = 0.0;
         self.open()
         bytes = list(((int)(1000 * voltage)).to_bytes(4, "little"))
-        self.uart.write(serial.to_bytes([2, constants.Rr1700Command.VoltageCommand, bytes[0], bytes[1], bytes[2], bytes[3]]))
+        self.uart.write(serial.to_bytes([2, constants.VOLTAGE_COMMAND, bytes[0], bytes[1], bytes[2], bytes[3]]))
         sleep(0.5)
         self.close()
 
@@ -218,7 +191,7 @@ class IvMpp(PvBlock):
         self.open()
         bytes = list(((int)(1000 * voltage)).to_bytes(4, "little"))
         self.uart.write(
-            serial.to_bytes([2, constants.Rr1700Command.VoltageCommand, bytes[0], bytes[1], bytes[2], bytes[3]]))
+            serial.to_bytes([2, constants.VOLTAGE_COMMAND, bytes[0], bytes[1], bytes[2], bytes[3]]))
         sleep(0.5)
         self.close()
 
@@ -226,12 +199,12 @@ class IvMpp(PvBlock):
         self.open()
 
         self.uart.write(
-            serial.to_bytes([2, constants.Rr1700Command.SetTriggerCommand, 0]))
+            serial.to_bytes([2, constants.SET_TRIGGER_COMMAND, 0]))
 
         sleep(0.5)
 
         self.uart.write(
-            serial.to_bytes([2, constants.Rr1700Command.CurveCommand, points, delay_ms, 0, 0, 0, 0, sweepstyle]))
+            serial.to_bytes([2, constants.CURVE_COMMAND, points, delay_ms, 0, 0, 0, 0, sweepstyle]))
 
         while self.uart.inWaiting() != 3:
             sleep(0.01)
@@ -244,7 +217,6 @@ class IvMpp(PvBlock):
             status = self.read_statusbyte()
 
         self.close()
-
         points_measured = status.statusbytes[0]
         curve = self.transfer_curve(points_measured)
 
@@ -252,7 +224,7 @@ class IvMpp(PvBlock):
 
     def transfer_curve(self, points):
         self.open()
-        self.uart.write(serial.to_bytes([2, constants.Rr1700Command.TransferCurveCommand]))
+        self.uart.write(serial.to_bytes([2, constants.TRANSFER_CURVE_COMMAND]))
         sleep(0.5)
         availablebytes = 8 + (points * 8) + 1
         toread = self.uart.inWaiting()
@@ -266,8 +238,7 @@ class IvMpp(PvBlock):
         voltages = []
         currents = []
 
-
-        for i in range(int((availablebytes - 1)/8)):
+        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
@@ -289,7 +260,7 @@ class IvMpp(PvBlock):
         bts = list(address.to_bytes(2, 'little'))
         self.open()
         self.uart.write(
-            serial.to_bytes([2, constants.Rr1700Command.ReadEepromCommand, length, bts[0], bts[1]]))
+            serial.to_bytes([2, constants.READ_EEPROM_COMMAND, length, bts[0], bts[1]]))
 
         while self.uart.inWaiting() != length + 3:
             sleep(0.01)
@@ -303,7 +274,7 @@ class PvIrr(PvBlock):
 
     def ReadIrradiances(self):
         self.open()
-        self.uart.write(serial.to_bytes([2, constants.Rr1700Command.ReadCommand]))
+        self.uart.write(serial.to_bytes([2, constants.READ_COMMAND]))
         sleep(0.5)
         bts = ReadSerial(self.uart)
         if len(bts) < 10:
@@ -343,10 +314,3 @@ class IvPoint(object):
     def __str__(self):
         return "(%f, %f)" % (self.voltage, self.current)
 
-
-class SweepStyle(IntEnum):
-    ISC_TO_VOC = 0,
-    SWEEP_VOC_TO_ISC = 1,
-    EXTENT_CURVE_DELAY = 2,
-    SWEEP_VOC_ISC_VOC = 4,
-    SWEEP_ISC_VOC_ISC = 8

{pvblocks-0.1.0 → pvblocks-0.1.2}/src/pvblocks.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pvblocks
-Version: 0.1.0
+Version: 0.1.2
 Summary: Python package to directly control pvblocks modules
 Author-email: Erik Haverkamp <erik@rera.nl>
 Project-URL: Homepage, https://github.com/rerasolutions/pvblocks-python

{pvblocks-0.1.0 → pvblocks-0.1.2}/src/pvblocks.egg-info/SOURCES.txt

@@ -10,4 +10,5 @@ src/pvblocks.egg-info/PKG-INFO
 src/pvblocks.egg-info/SOURCES.txt
 src/pvblocks.egg-info/dependency_links.txt
 src/pvblocks.egg-info/top_level.txt
-tests/test.py
+tests/test.py
+tests/testui.py

{pvblocks-0.1.0 → pvblocks-0.1.2}/tests/test.py

@@ -1,10 +1,12 @@
 from pvblocks import pvblocks_system
 from time import sleep
+from pvlib.ivtools.utils import rectify_iv_curve
+import numpy as np
 
 print("PV-Blocks version: " + pvblocks_system.show_version())
 
 pvblocks = pvblocks_system.PvBlocks('COM16')
-
+import matplotlib.pyplot as plt
 
 if pvblocks.init_system():
     print("init ok")
@@ -37,6 +39,17 @@ if len(pvblocks.IvMppBlocks) > 0:
 #print(iv_mpp.get_info())
 ivpoint = iv_mpp.read_ivpoint()
 print(ivpoint)
-#curve = iv_mpp.MeasureIvCurve(100, 20, 0)
-
-#pvblocks.close_system()
+curve = iv_mpp.measure_ivcurve(100, 20, 0)
+(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()

pvblocks-0.1.2/tests/testui.py

@@ -0,0 +1,395 @@
+import datetime
+import pathlib
+import ttkbootstrap as ttk
+from ttkbootstrap.constants import *
+from ttkbootstrap import utility
+from matplotlib.figure import Figure
+from matplotlib.backends.backend_tkagg import (FigureCanvasTkAgg, NavigationToolbar2Tk)
+import serial.tools.list_ports
+import pickle
+import os
+from pvblocks import pvblocks_system
+
+
+class MainApp(ttk.Frame):
+
+    def __init__(self, master):
+        super().__init__(master, padding=15)
+        self.pack(fill=BOTH, expand=YES)
+
+
+        self.master = master
+
+        self.online = False
+        self.is_active = False
+        self.voltages = []
+        self.currents = []
+        self.pvblocks = None
+        self.iv_mpp = None
+        self.load_settings()
+
+
+
+        self.fig = Figure((6, 4), dpi=100)
+        # application variables
+        self.points_var = ttk.StringVar(value=self.settings['points'])
+        self.delay_var = ttk.StringVar(value=self.settings['delay_ms'])
+        self.mode_var = ttk.StringVar(value='voc')
+        self.sweepstyle_var = ttk.StringVar(value=self.settings['sweepstyle'])
+        self.ivpoint_var = ttk.StringVar(value='(,)')
+
+        self.isc_var = ttk.StringVar(value='0.000')
+        self.voc_var = ttk.StringVar(value='0.000')
+        self.impp_var = ttk.StringVar(value='0.000')
+        self.vmpp_var = ttk.StringVar(value='0.000')
+        self.ff_var = ttk.StringVar(value='0.000')
+        self.power_var = ttk.StringVar(value='0.000')
+
+
+        self.create_menu()
+        # header and labelframe option container
+        option_text = "IV/MPP Load control"
+        self.option_lf = ttk.Labelframe(self, text=option_text, padding=15)
+        self.option_lf.pack(fill=X, expand=YES, anchor=N)
+
+        data_text = "Measurement"
+        self.data_lf = ttk.Labelframe(self, text=data_text, padding=15)
+        self.data_lf.pack(fill=X, expand=YES, anchor=N)
+
+
+        self.create_mode_row()
+        self.create_curveinput_row()
+        self.create_ivpoint_row()
+
+        self.create_graph()
+        self.create_parameters_table('Isc:', self.isc_var)
+        self.create_parameters_table('Voc:', self.voc_var)
+        self.create_parameters_table('Impp:', self.impp_var)
+        self.create_parameters_table('Vmpp:', self.vmpp_var)
+        self.create_parameters_table('Power:', self.power_var)
+        self.create_parameters_table('FF:', self.ff_var)
+        self.create_save_button()
+
+
+        self.draw_empty_figure()
+        self.update_controls()
+
+
+
+
+    def create_menu(self):
+        self.menu = ttk.Menu(self.master)
+        self.master.config(menu=self.menu)
+        self.connect_menu = ttk.Menu(self.menu)
+        self.menu.add_cascade(label='File', menu=self.connect_menu)
+        self.connect_menu.add_command(label='Connect...', command=self.connect)
+        self.connect_menu.add_command(label='Disconnect...', command=self.disconnect, state='disabled')
+        self.connect_menu.add_separator()
+        self.connect_menu.add_command(label='Exit', command=self.exit_app)
+        self.configmenu = ttk.Menu(self.menu)
+        self.menu.add_cascade(label='Configure', menu=self.configmenu)
+        self.configmenu.add_command(label='Select serialport', command=self.open_comport_window)
+        self.helpmenu = ttk.Menu(self.menu)
+        self.menu.add_cascade(label='Help', menu=self.helpmenu)
+        self.helpmenu.add_command(label='About')
+
+    def create_parameters_table(self, caption, variable):
+        isc_row = ttk.Frame(self.data_lf)
+        isc_row.pack(side=TOP, expand=YES, pady=1)
+        lbl = ttk.Label(master=isc_row, text=caption, width=10)
+        lbl.pack(side=LEFT, padx=5)
+        isc_ent = ttk.Entry(master=isc_row, textvariable=variable)
+        isc_ent.pack(side=LEFT, padx=5, fill=X, expand=YES)
+
+    def create_save_button(self):
+        isc_row = ttk.Frame(self.data_lf)
+        isc_row.pack(side=TOP, fill=X, pady=1)
+        self.save_btn = ttk.Button(
+            master=isc_row,
+            text="Save data",
+            command=self.save_data
+        )
+        self.save_btn.pack(side=TOP, fill=X, padx=5)
+
+
+
+    def create_ivpoint_row(self):
+        """Add path row to labelframe"""
+        ivpoint_row = ttk.Frame(self.option_lf)
+        ivpoint_row.pack(fill=X, expand=YES)
+        ivpoint_lbl = ttk.Label(ivpoint_row, text="IV-Point", width=8)
+        ivpoint_lbl.pack(side=LEFT, padx=(15, 0))
+        ivpoint_ent = ttk.Entry(ivpoint_row, textvariable=self.ivpoint_var)
+        ivpoint_ent.pack(side=LEFT, fill=X, expand=YES, padx=5)
+        self.measure_ivpoint_btn = ttk.Button(
+            master=ivpoint_row,
+            text="Measure point",
+            command = self.measure_ivpoint,
+            width=18
+        )
+        self.measure_ivpoint_btn.pack(side=LEFT, padx=5)
+
+    def create_curveinput_row(self):
+        """Add term row to labelframe"""
+        term_row = ttk.Frame(self.option_lf)
+        term_row.pack(fill=X, expand=YES, pady=15)
+        points_lbl = ttk.Label(term_row, text="Points", width=8)
+        points_lbl.pack(side=LEFT, padx=(15, 0))
+        points_ent = ttk.Entry(term_row, textvariable=self.points_var)
+        points_ent.pack(side=LEFT, fill=X, expand=YES, padx=5)
+        delay_lbl = ttk.Label(term_row, text="Delay [ms]", width=8)
+        delay_lbl.pack(side=LEFT, padx=(15, 0))
+        delay_ent = ttk.Entry(term_row, textvariable=self.delay_var)
+        delay_ent.pack(side=LEFT, fill=X, expand=YES, padx=5)
+
+        sweepstyle_ent = ttk.Combobox(term_row, state="readonly", textvariable=self.sweepstyle_var,
+                                      values=("Isc to Voc", "Voc to Isc", "Isc to Voc to Isc", "Voc to Isc to Voc"))
+        sweepstyle_ent.pack(side=LEFT, fill=X, expand=YES)
+
+
+
+        self.measureCurveBtn = ttk.Button(
+            master=term_row,
+            text="Measure Curve",
+            command = self.system_measure_curve,
+            width=18
+        )
+        self.measureCurveBtn.pack(side=LEFT, padx=5)
+
+    def create_mode_row(self):
+        """Add type row to labelframe"""
+        type_row = ttk.Frame(self.option_lf)
+        type_row.pack(fill=X, expand=YES, pady=15)
+        type_lbl = ttk.Label(type_row, text="Mode", width=8)
+        type_lbl.pack(side=LEFT, padx=(15, 0))
+
+        voc_opt = ttk.Radiobutton(
+            master=type_row,
+            text="Voc mode",
+            variable=self.mode_var,
+            value="voc"
+        )
+        voc_opt.pack(side=LEFT)
+
+        isc_opt = ttk.Radiobutton(
+            master=type_row,
+            text="Isc mode",
+            variable=self.mode_var,
+            value="isc"
+        )
+        isc_opt.pack(side=LEFT, padx = 5)
+        voc_opt.invoke()
+
+        self.apply_btn = ttk.Button(
+            master=type_row,
+            text="Apply",
+            command=self.on_apply,
+            width=8
+        )
+        self.apply_btn.pack(side=LEFT, padx=5)
+
+    def create_graph(self):
+        print("Create graph")
+        canvas = FigureCanvasTkAgg(self.fig, master=self.data_lf)
+        canvas.get_tk_widget().pack(side=LEFT)
+
+    def on_apply(self):
+        print(self.mode_var.get())
+        if self.mode_var.get() == 'isc':
+            self.iv_mpp.ApplyIsc()
+        else:
+            self.iv_mpp.ApplyVoc()
+
+    def system_measure_curve(self):
+
+        print('measure curve')
+        self.save_btn.configure(state=ttk.DISABLED)
+        self.is_active = True
+        self.update_controls()
+        self.voltages = []
+        self.currents = []
+        self.draw_empty_figure()
+        self.master.update()
+        self.save_settings()
+
+        sweepstl = 0
+
+        if self.sweepstyle_var.get() == 'Isc to Voc':
+            sweepstl = 0
+        if self.sweepstyle_var.get() == 'Voc to Isc':
+            sweepstl = 1
+        if self.sweepstyle_var.get() == 'Isc to Voc to Isc':
+            sweepstl = 8
+        if self.sweepstyle_var.get() == 'Voc to Isc to Voc':
+            sweepstl = 4
+
+        curve = self.iv_mpp.measure_ivcurve(int(self.points_var.get()), int(self.delay_var.get()), sweepstl)
+
+        self.voltages = curve['voltages']
+        self.currents = curve['currents']
+        self.refresh_figure()
+        self.is_active = False
+        self.update_controls()
+        self.save_btn.configure(state=ttk.NORMAL)
+
+
+    def measure_ivpoint(self):
+        print('measure point')
+        self.is_active = True
+        self.update_controls()
+        ivpoint = self.iv_mpp.read_ivpoint()
+        voltage = ivpoint.voltage
+        current = ivpoint.current
+        self.ivpoint_var.set('Voltage: %f V, Current: %f A, Power: %f W' % (voltage, current, voltage * current))
+        self.is_active = False
+        self.update_controls()
+        pass
+
+
+    def system_connect(self):
+        if self.online:
+            self.disconnect()
+        else:
+            self.connect()
+
+    def exit_app(self):
+        print('exit app')
+        if self.online:
+            self.disconnect()
+        self.master.quit()
+
+    def connect(self):
+        self.online = False
+        print('connect pvblocks using: ' + self.settings['serialport'])
+        self.pvblocks = pvblocks_system.PvBlocks(self.settings['serialport'])
+        if self.pvblocks.init_system():
+            print("init ok")
+            print("scanning available blocks")
+
+            if self.pvblocks.scan_blocks():
+                print("scan_blocks returns ok")
+                self.iv_mpp = None
+                if len(self.pvblocks.IvMppBlocks) > 0:
+                    self.iv_mpp = self.pvblocks.IvMppBlocks[0]
+                    self.online = True
+                    print("Found IV-MPP block")
+            else:
+                print("scan_blocks failed")
+
+        else:
+            print("failed")
+
+        self.update_controls()
+
+    def disconnect(self):
+        print('disconnect pvblocks')
+        self.pvblocks.close_system()
+        self.online = False
+        self.update_controls()
+
+    def refresh_figure(self):
+        self.fig.clear()
+        ax = self.fig.add_subplot(111)
+        ax.scatter(self.voltages, self.currents)
+        self.fig.canvas.draw_idle()
+
+    def draw_empty_figure(self):
+        y = []
+        x = []
+        ax = self.fig.add_subplot(111)
+        ax.scatter(x, y)
+        self.fig.canvas.draw()
+
+    def save_data(self):
+        pass
+
+
+    def open_comport_window(self):
+        # Create a new top-level window
+        comport_window = ttk.Toplevel(self.master)
+        comport_window.title("Select Serial Port")
+        comport_window.geometry("300x150")
+
+        # Make the window modal
+        comport_window.grab_set()
+
+        # Label instructing the user
+        label = ttk.Label(comport_window, text="Select a serial port:")
+        label.pack(pady=10)
+
+        # List of COM ports - customizable
+        com_ports = []
+        for c in serial.tools.list_ports.comports():
+            com_ports.append(c.device)
+
+        # Variable to hold the selected port
+        selected_port = ttk.StringVar()
+
+        # Combobox for selecting COM port
+        combo = ttk.Combobox(comport_window, values=com_ports, textvariable=selected_port)
+        combo.pack(pady=5)
+        combo.current(0)  # Set default selection
+
+        # Function to handle selection
+        def select_port():
+            self.settings['serialport'] = selected_port.get()
+            self.save_settings()
+            comport_window.grab_release()
+            comport_window.destroy()
+
+        # Button to confirm selection
+        select_button = ttk.Button(comport_window, text="Select", command=select_port)
+        select_button.pack(pady=10)
+
+    def update_controls(self):
+        if self.online:
+            self.connect_menu.entryconfig(0, state=ttk.DISABLED)
+            self.connect_menu.entryconfig(1, state=ttk.NORMAL)
+        else:
+            self.connect_menu.entryconfig(0, state=ttk.NORMAL)
+            self.connect_menu.entryconfig(1, state=ttk.DISABLED)
+            self.save_btn.configure(state=ttk.DISABLED)
+
+
+        if self.is_active:
+            self.measureCurveBtn.configure(state=ttk.DISABLED)
+            self.measure_ivpoint_btn.configure(state=ttk.DISABLED)
+            self.apply_btn.configure(state=ttk.DISABLED)
+        else:
+            if self.online:
+                self.measureCurveBtn.configure(state=ttk.NORMAL)
+                self.measure_ivpoint_btn.configure(state=ttk.NORMAL)
+                self.apply_btn.configure(state=ttk.NORMAL)
+            else:
+                self.measureCurveBtn.configure(state=ttk.DISABLED)
+                self.measure_ivpoint_btn.configure(state=ttk.DISABLED)
+                self.apply_btn.configure(state=ttk.DISABLED)
+
+        self.master.update()
+
+    def save_settings(self):
+        self.settings['points'] = self.points_var.get()
+        self.settings['delay_ms'] = self.delay_var.get()
+        self.settings['sweepstyle'] = self.sweepstyle_var.get()
+        with open('settings.pkl', 'wb') as f:
+            pickle.dump(self.settings, f)
+
+    def load_settings(self):
+        self.settings = {'serialport': 'COM1', 'points': '100', 'delay_ms': '20', 'sweepstyle': 'Isc to Voc'}
+
+        if os.path.isfile('settings.pkl'):
+            with open('settings.pkl', 'rb') as f:
+                self.settings = pickle.load(f)
+        else:
+            with open('settings.pkl', 'wb') as f:
+                pickle.dump(self.settings, f)
+
+        for key in self.settings.keys():
+            print(self.settings[key])
+
+
+if __name__ == '__main__':
+
+    app = ttk.Window("PVBlocks IV/MPP Control", "journal")
+    MainApp(app)
+    app.mainloop()

pvblocks-0.1.0/src/pvblocks/__init__.py

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

pvblocks-0.1.0/src/pvblocks/constants.py

@@ -1,42 +0,0 @@
-from enum import IntEnum
-
-class Rr1700Command(IntEnum):
-    IdleCommand = 0,
-    BlinkCommand = 1,
-    VoltageCommand = 2,
-    MppCommand = 3,
-    ReadCommand = 4,
-    CurveCommand = 5,
-    TransferCurveCommand = 6,
-    ExternalMppCommand = 7,
-    TriggeredCurveCommand = 8,
-    GetStatus = 13,
-    WriteEepromCommand = 14,
-    SetTriggerCommand = 15,
-    ReadEepromCommand = 16,
-    UpdateConfigCommand = 17,
-    GetConfigCommand = 18,
-    StartFirmwareUpdate = 19,
-    EnableFastCommunications = 20,
-    DisableBroadcast = 21,
-    TriggeredReadCommand = 50,
-    Alive = 100,
-    ListModules = 101,
-    OpenModule = 106,
-    CloseModule = 107,
-    ResetModule = 108,
-    ResetController = 109,
-    TriggerAll = 110,
-    BroadcastThresholdExceeded = 111,
-    CurveRunning = 250
-
-class Rr1700Function(IntEnum):
-    IvMppReadIVPoint = 20,
-    IvMppApplyState = 21,
-    PvIrrReadIrradiances = 30
-
-class IvMppState(IntEnum):
-    Voc = 0,
-    Isc = 1,
-    Mpp = 2,
-    VoltageBias = 3