Plot_test_MVC.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adding motor MY-LARGE-MOTOR with units m\n",
      "Adding motor MY-TINY-MOTOR with units nm\n",
      "Adding motor MY-NORMAL-MOTOR with units mm\n",
      "Adding diode INTENSITY\n",
      "Adding diode COUNTER\n",
      "Adding diode SIGNAL\n",
      "Adding diode XRF\n",
      "Adding camera MY-CAMERA\n",
      "0 Start\n",
      "1 Stop\n",
      "2 Stepsize\n",
      "Test on diode INTENSITY state at start: !alternate: True, !selected: True\n",
      "Test on diode COUNTER state at start: !alternate: True, !selected: True\n",
      "Test on diode SIGNAL state at start: !alternate: True, !selected: True\n",
      "Test on diode XRF state at start: !alternate: True, !selected: True\n",
      "Test on camera MY-CAMERA state at start: !alternate: True, !selected: True\n"
     ]
    }
   ],
   "source": [
    "from toydaq import Motor, Diode, Camera, scan_iter\n",
    "\n",
    "\n",
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "from tkinter.messagebox import *\n",
    "\n",
    "from matplotlib.figure import Figure\n",
    "from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk\n",
    "from matplotlib import cm\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "#from threading import Thread\n",
    "from tqdm import tqdm\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "\n",
    "# I use tkinter for creating the GUI and follow the MVC design patter to follow a serparate of concerns.\n",
    "# Model: all hardware components inside and a future place for scan methods\n",
    "# View: the GUI, visualises output, hardware. Talks to the user and the controller. Performs basic tasks like plotting and checks if parameter are selected\n",
    "# Controller: Performs the workflows to bring motors and diodes, camera together. Sends events to functions\n",
    " \n",
    "class Model():\n",
    "    \"\"\" The model for our beamline. It contains our hardware, i.e. diodes, cameras, motors.\"\"\"\n",
    "    \n",
    "    # Configuration of our beamline. Ex[ected parameters for the hardware.\n",
    "    valid_units = [\"m\", \"nm\", \"mm\"]\n",
    "    valid_diode_names=[\"INTENSITY\", \"COUNTER\", \"SIGNAL\", \"XRF\"]\n",
    "    valid_camera_names=[\"MY-CAMERA\"]\n",
    "    \n",
    "    def __init__(self):\n",
    "        \"\"\"\n",
    "        Make motors, diodes, cameras available in the model with their methods and attributes.\n",
    "        better in the future: load from a config file\n",
    "        \"\"\"\n",
    "        self.motors = {}\n",
    "        self.diodes = {}\n",
    "        self.cameras = {}\n",
    "\n",
    "    def _check_valid_units(self, units):\n",
    "        \"\"\"\n",
    "        Ensure the user has provided a valid unit name\n",
    "        \"\"\"\n",
    "        if units not in self.valid_units:\n",
    "            options = \", \".join(self.valid_units)\n",
    "            raise ValueError(f\"{units} is not a known unit type. Options are {options}\")\n",
    "\n",
    "    def add_motor(self, name, units):\n",
    "        \"\"\"\n",
    "        Add a motor to the model\n",
    "        \"\"\"\n",
    "        if name in self.motors:\n",
    "            raise ValueError(\n",
    "                f\"Motor names must be unique: {name} is already a defined motor.\"\n",
    "            )\n",
    "\n",
    "        # Allow any casing\n",
    "        units = units.lower()\n",
    "        self._check_valid_units(units)\n",
    "        print(f\"Adding motor {name} with units {units}\")\n",
    "        self.motors[name] = Motor(name, units)\n",
    "\n",
    "    def _check_valid_diode_names(self, diode_name):\n",
    "        \"\"\"\n",
    "        Ensure the user has provided a valid diode name\n",
    "        \"\"\"   \n",
    "        if diode_name not in self.valid_diode_names:\n",
    "            options = \", \".join(self.valid_diode_names)\n",
    "            raise ValueError(f\"{diode_name} is not a known sensor diode name. Options are {options}\")\n",
    "\n",
    "    def add_diode(self, diode_name):\n",
    "        \"\"\"\n",
    "        Add a diode to the model\n",
    "        \"\"\"\n",
    "        if diode_name in self.diodes:\n",
    "            raise ValueError(\n",
    "                f\"Diode names must be unique: {diode_name} is already a defined diode.\"\n",
    "            )\n",
    "        \n",
    "        self._check_valid_diode_names(diode_name)\n",
    "        print(f\"Adding diode {diode_name}\")\n",
    "        self.diodes[diode_name]=Diode(diode_name)\n",
    "\n",
    "    def _check_valid_camera_names(self, camera_name):\n",
    "        \"\"\"\n",
    "        Ensure the user has provided a valid camera name\n",
    "        \"\"\"   \n",
    "        if camera_name not in self.valid_camera_names:\n",
    "            options = \", \".join(self.valid_camera_names)\n",
    "            raise ValueError(f\"{camera_name} is not a known sensor diode name. Options are {options}\")\n",
    "\n",
    "\n",
    "    def add_camera(self, camera_name):\n",
    "        \"\"\"Add a camera to the model\"\"\"\n",
    "\n",
    "        if camera_name in self.cameras:\n",
    "            raise ValueError(f\"Camera names must be unique: {camera_name} is already a defined camera.\")\n",
    "        self._check_valid_camera_names(camera_name)\n",
    "        print(f\"Adding camera {camera_name}\")\n",
    "        self.cameras[camera_name]=Camera(camera_name)\n",
    "\n",
    "  \n",
    "    def diode_names(self):\n",
    "        \"\"\" Return names of all available diodes \"\"\"\n",
    "        return [self.diodes[label].name for label in self.diodes]\n",
    "\n",
    "    def motor_names(self):\n",
    "        \"\"\" Return names of all available motors \"\"\"\n",
    "        return [self.motors[label].name for label in self.motors]\n",
    "\n",
    "    def camera_names(self):\n",
    "        \"\"\" Return names of all available cameras \"\"\"\n",
    "        return [self.cameras[label].name for label in self.cameras]\n",
    "    \n",
    "class View():\n",
    "    # The view will be responsible for displaying widgets\n",
    "    # and getting some information from user and from model.\n",
    "\n",
    "    def __init__(self, model):\n",
    "        \"\"\" Creates the main frame and links other frames to it. Only this layer should be visible to the model and controller. \"\"\"\n",
    "\n",
    "        self._model = model\n",
    "\n",
    "        self._master = tk.Tk()\n",
    " \n",
    "        self._frame = tk.Frame(self._master)\n",
    "        self.fig = Figure(figsize=(7.5, 4), dpi=80)\n",
    "\n",
    "        self.ax0 = self.fig.add_subplot()\n",
    "        self._frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=1)\n",
    "        \n",
    "        # The canvas is the drawing arrea\n",
    "        self.canvas = FigureCanvasTkAgg(self.fig, master=self._frame)\n",
    "        # Navigation toolbar for the canvas\n",
    "        toolbar = NavigationToolbar2Tk(self.canvas, self._frame)\n",
    "        toolbar.update()\n",
    "        self.canvas.get_tk_widget().pack(side=tk.LEFT, fill=tk.BOTH, expand=1)\n",
    "\n",
    "        self.sidepanel = SidePanel(self._frame, self,  self._model)   #parent,  guicontrol, model as parame for SidePannel, this is how you establish communication :-)\n",
    "        self.motorpanel= MotorPanel(self._frame, self, self._model)   #parent,  guicontrol, model as parame for Motorpanel \n",
    "\n",
    "\n",
    "        self.cbVariables={}\n",
    "        self.cb={}\n",
    "        #self.cbTexts={}\n",
    "        #create checkboxes for diodes\n",
    "        for diode_name in self._model.diode_names():\n",
    "            self.cbVariables[diode_name]=tk.IntVar() #default value=0   #master=self.view.sidepanel.frame3\n",
    "            #self.cbTexts[diode_name] = tk.StringVar()\n",
    "            self.cb[diode_name]=ttk.Checkbutton(self.sidepanel.frame3,text=diode_name, variable=self.cbVariables[diode_name], state=['!alternate','!selected'], offvalue=0, onvalue=1, command=lambda diode_name=diode_name: self.on_cb_diode_selection(diode_name))\n",
    "            self.cb[diode_name].pack(side=tk.TOP, anchor=tk.W) \n",
    "            print(f\"Test on diode {diode_name} state at start: !alternate: {self.cb[diode_name].instate(['!alternate'])}, !selected: {self.cb[diode_name].instate(['!selected'])}\") \n",
    "\n",
    "\n",
    "        self.cbVariables_cam={}\n",
    "        self.cb_cam={}\n",
    "        # create checkboxes for cameras\n",
    "        for camera_name in self._model.camera_names():\n",
    "            self.cbVariables_cam[camera_name]=tk.IntVar()\n",
    "            self.cb_cam[camera_name]=ttk.Checkbutton(self.sidepanel.frame5,text=camera_name, variable=self.cbVariables_cam[camera_name], state=['!alternate','!selected'], offvalue=0, onvalue=1, command=lambda camera_name=camera_name: self.on_cb_cam_selection(camera_name))\n",
    "            self.cb_cam[camera_name].pack(side=tk.TOP, anchor=tk.W) \n",
    "            print(f\"Test on camera {camera_name} state at start: !alternate: {self.cb_cam[camera_name].instate(['!alternate'])}, !selected: {self.cb_cam[camera_name].instate(['!selected'])}\") \n",
    "\n",
    "\n",
    "    # Methods \n",
    "           \n",
    "    def on_create_scanplot(self, m):\n",
    "        \"\"\" Connects the 1D scan plot button to a method \"\"\"\n",
    "        self.sidepanel.plotBut.bind(\"<Button>\", m)\n",
    "\n",
    "    def on_create_camplot(self, m):\n",
    "        \"\"\" Connects the plot cam scan button to a method \"\"\"\n",
    "        self.sidepanel.plotCamBut.bind(\"<Button>\", m)\n",
    "\n",
    "    def on_clear(self, m):\n",
    "        \"\"\" Clear canvas area \"\"\"\n",
    "        self.sidepanel.clearButton.bind(\"<Button>\", m)\n",
    "\n",
    "    def on_combobox_selection(self, m):  \n",
    "        \"\"\" Connects combobox to a method \"\"\"\n",
    "        self.sidepanel.motor_selCombo.bind(\"<<ComboboxSelected>>\", m)    \n",
    "\n",
    "    def on_show_scan_settings(self,m):\n",
    "        \"\"\" Connects the button show scan settings to a method \"\"\"\n",
    "        self.motorpanel.show_scan_settingsButton.bind(\"<Button>\", m)\n",
    "\n",
    "    def on_cb_diode_selection(self,diode_name): \n",
    "        \"\"\" Prints out the current state of a diode \"\"\"\n",
    "        print(f\"Diode {diode_name} is {self.cb[diode_name].state()}\")\n",
    "\n",
    "    def on_cb_cam_selection(self,camera_name): \n",
    "        \"\"\" Prints out the current state of a camera \"\"\"\n",
    "        print(f\"Camera {camera_name} is {self.cb_cam[camera_name].state()}\")\n",
    "\n",
    "        \n",
    "    def run(self):\n",
    "        \"\"\" Main method to start the GUI \"\"\"\n",
    "        self._master.geometry(\"1200x600\")\n",
    "        self._master.title(\"Tkinter MVC example\")\n",
    "        self._master.deiconify()\n",
    "        self._master.mainloop()\n",
    "\n",
    "    def on_motor_selection(self, mot_selected):\n",
    "        \"\"\" Sends information about current motor to the label \"\"\"\n",
    "        # shows the selected motor and its position in the label\n",
    "        #self.sidepanel.curr_motor_valLabel.configure(text=self._model.motors[mot_selected])\n",
    "        self.sidepanel.curr_motor_val.set(self._model.motors[mot_selected])\n",
    "\n",
    "        print(f\"{mot_selected} was selected.\")\n",
    "\n",
    "        # adjust the units shown above the motor input values, when the motor is changed by the user \n",
    "        for column in self.motorpanel.motor_inputTexts:\n",
    "            self.motorpanel.motor_inputTexts[column].set(f\"{column} [{self._model.motors[mot_selected].units}]\")\n",
    "           \n",
    "        # return motor as object \n",
    "        return self._model.motors[mot_selected]\n",
    "\n",
    "\n",
    "    def update_current_motor_pos(self, mot_selected):\n",
    "        \"\"\" Sends current motor information to the label \"\"\"\n",
    "        # The plan was to use this function to show a continuous update of the motor values. But I need threading. Not yet implemented.\n",
    "        self.sidepanel.curr_motor_val.set(self._model.motors[mot_selected])\n",
    "\n",
    "    def get_motor_selection(self):\n",
    "        \"\"\" Get current motor selection from combobox and return motor \"\"\"\n",
    "        try:\n",
    "            if self.sidepanel.motor_selCombo.get() == \"\":  \n",
    "                raise ValueError('No motor selected')\n",
    "            else:\n",
    "                print('Current selected motor ', self.sidepanel.motor_selCombo.get())\n",
    "\n",
    "                #returns only the motor name, i.e. str\n",
    "                #return self.sidepanel.motor_selCombo.get()\n",
    "                # returns a motor object\n",
    "                return self._model.motors[self.sidepanel.motor_selCombo.get()]\n",
    "\n",
    "        except ValueError as e:\n",
    "            self.no_motor_selected()\n",
    "            showwarning(title='Empty motor selection', message=\"Select motor.\")\n",
    "        \n",
    "    def get_diode_selection(self):\n",
    "        \"\"\" Returns which diodes is selected. Two choices: by state or by variable. I went with by variable.\"\"\"\n",
    "        #for label in self.cbVariables:\n",
    "        #    print(label, self.cbVariables[label].get())\n",
    "\n",
    "        for diode_name in self.cb:\n",
    "            if self.cb[diode_name].instate(['selected']) == True:\n",
    "                print(f\"Diode {diode_name} is selected.\")\n",
    "\n",
    "        diodes_cb_values=[v.get() for v in self.cbVariables.values()]\n",
    "        print(diodes_cb_values)\n",
    "\n",
    "        if all([ w == 0 for w in diodes_cb_values]):\n",
    "            self.no_diode_selected()\n",
    "            return \n",
    "        else:\n",
    "            all_selected_diodes={k:v for (k,v) in self.cbVariables.items() if v.get() == 1}\n",
    "            print(all_selected_diodes, \"type is\", type(all_selected_diodes))\n",
    "        # returns a dict of selected diodes\n",
    "        return all_selected_diodes\n",
    "\n",
    "    def get_camera_selection(self):\n",
    "        \"\"\" Gets the current camera selection \"\"\"\n",
    "        cameras_cb_values=[v.get() for v in self.cbVariables_cam.values()]\n",
    "\n",
    "        if all([ w == 0 for w in cameras_cb_values]):\n",
    "            self.no_camera_selected()\n",
    "            return \n",
    "        else:\n",
    "            all_selected_cameras={k:v for (k,v) in self.cbVariables_cam.items() if v.get() == 1}\n",
    "            print(all_selected_cameras, \"type is\", type(all_selected_cameras))\n",
    "\n",
    "        # Our model beamline has only one camera curently. \n",
    "        if np.sum(cameras_cb_values) !=1:\n",
    "            showwarning(title=\"Select one camera\", message=\"Select one camera.\")\n",
    "\n",
    "        # returns a dict of selected cameras\n",
    "        return all_selected_cameras\n",
    " \n",
    "\n",
    "    def show_scan_settings(self): \n",
    "        \"\"\" Current motor, start, stop, stepsize is shown \"\"\"\n",
    "        curr_mot_selected=self.get_motor_selection().name  #str\n",
    "        print(f\"{curr_mot_selected} is selected.\")\n",
    "        # access the ttk.Entry \n",
    "        out_strings=[]\n",
    "        for column in self.motorpanel.motor_inputTexts:\n",
    "            print(print('Identify', self.motorpanel.entries[column]))\n",
    "            # Label : Value\n",
    "            out_str=f\"{self.motorpanel.motor_inputTexts[column].get()}: {self.motorpanel.entriesValues[column].get()}\"\n",
    "            print(out_str)\n",
    "            out_strings.append(out_str)\n",
    "\n",
    "            # Both options possible, get only one, I go for the Variables of the ttk.Entry\n",
    "            #print(f\"This is the current Variable for {self.motorpanel.entries[column]}: {self.motorpanel.entriesValues[column].get()}\")\n",
    "            #print(\"This is the current value via.get on the ttk.Entry\", self.motorpanel.entries[column].get())\n",
    "        showinfo(\"Current scan settings\", f\"Motor: {curr_mot_selected}, {str(out_strings)[1:-1]}\")\n",
    "        \n",
    "    def retrieve_scan_settings(self):\n",
    "        \"\"\" Collect scan settings \"\"\"\n",
    "\n",
    "        mot_selected=self.get_motor_selection()\n",
    "        mot_scan_settings=self.motorpanel.entriesValues\n",
    "\n",
    "        return (mot_selected, mot_scan_settings)\n",
    "\n",
    "\n",
    "    def line_colors(self, number_of_lines):\n",
    "        \"\"\" Create better line colors \"\"\"\n",
    "        start = 0.0\n",
    "        stop = 1.0\n",
    "        cm_subsection = np.linspace(start, stop, number_of_lines)\n",
    "        colors = [cm.jet(x) for x in cm_subsection]\n",
    "        return colors\n",
    "        \n",
    "    def modify_1d_plot(self, mot, diodes):\n",
    "        \"\"\" Modify title and xlabel for 1D scan with diodes \"\"\"\n",
    "        self.ax0.set_title('1D Scan')\n",
    "        self.ax0.set_xlabel(f\"{mot.name} [{mot.units}]\")\n",
    "    \n",
    "    def plot_1d_scan(self, mot_selected, dio_selected, mot_values, dio_values):\n",
    "        \"\"\" Plot 1D scan, one motor, multiple diodes \"\"\"\n",
    "\n",
    "        # some graphic modificaton\n",
    "        self.modify_1d_plot(mot_selected, dio_selected)\n",
    "        marker = ['o', 'v', '^', '<', '>', 's', '8', 'p']\n",
    "        colors = ['b', 'g', 'r', 'c', 'm', 'k']\n",
    "        handles=[]\n",
    "        labels=[]\n",
    "        for i in range(len(dio_selected)):\n",
    "            line, =self.ax0.plot(mot_values, dio_values[i],  marker=marker[i], color=colors[i])\n",
    "            #keep infos on legend.\n",
    "            handles.append(line)\n",
    "            labels.append(dio_selected[i])\n",
    "        self.ax0.legend(handles,labels, loc=\"best\")\n",
    "        #this updates the plot (see Matplotlib doc)\n",
    "        self.canvas.draw_idle()\n",
    "        self.fig.canvas.flush_events()\n",
    "\n",
    "    def plot_cam_1d_scan(self, mot_selected, cam_image, camera):\n",
    "        \"\"\" Plot 1D scan with a camera, one motor, one camera \"\"\"\n",
    "        cam_im=self.ax0.imshow(cam_image, interpolation=\"none\")\n",
    "        self.ax0.set_title(f'1D Scan {camera}')\n",
    "        self.ax0.set_xlabel(f\"{camera} X\")\n",
    "        self.ax0.set_ylabel(f\"{camera} Y\")\n",
    "        self.canvas.draw_idle()\n",
    "        self.fig.canvas.flush_events()\n",
    "\n",
    "\n",
    "    def no_motor_selected(self):\n",
    "        \"\"\" Warning no motor selected \"\"\"\n",
    "        showwarning(title='1D scan warning', message=\"No motor selected for 1D scan.\")\n",
    "        \n",
    "    \n",
    "    def no_diode_selected(self):\n",
    "        \"\"\" Warning no diode selected \"\"\"\n",
    "        showwarning(title='1D scan warning', message=\"No diode selected for 1D scan.\")\n",
    "        \n",
    "    def no_camera_selected(self):\n",
    "        \"\"\" Warning no camera selected \"\"\"\n",
    "        showwarning(title='1D scan warning', message=\"No camera selected for 1D scan.\")\n",
    "\n",
    "class SidePanel():\n",
    "    \"\"\" This class contains the buttons, the combobox, the ouput label for the motor, label frames for diodes \"\"\"\n",
    "    def __init__(self, root, guicontrol, model):\n",
    "        self.guicontrol=guicontrol\n",
    "        self._model=model\n",
    "        self._frame2 = tk.Frame(root)\n",
    "        self._frame2.pack(side=\"top\", fill=tk.BOTH, expand=1)\n",
    "        self.plotBut = tk.Button(self._frame2, text=\"Plot 1D Scan\")\n",
    "        self.plotBut.pack(side=\"top\", fill=tk.BOTH)\n",
    "        self.plotCamBut = tk.Button(self._frame2, text=\"Plot Cam Scan\")\n",
    "        self.plotCamBut.pack(side=\"top\", fill=tk.BOTH)\n",
    "        self.clearButton = tk.Button(self._frame2, text=\"Clear\")\n",
    "        self.clearButton.pack(side=\"top\", fill=tk.BOTH)\n",
    "\n",
    "\n",
    "        # Create a frame\n",
    "        self.motor_sel_title=ttk.Label(self._frame2, text='Motor selection').pack()\n",
    "        motor_name=tk.StringVar() #Motornames are strings\n",
    "        self.motor_selCombo=ttk.Combobox(self._frame2, textvariable=motor_name)\n",
    "        self.motor_selCombo['values']=self._model.motor_names()\n",
    "        self.motor_selCombo['state'] = 'readonly'\n",
    "        #motor_sel.grid(column=0, row=1)\n",
    "        self.motor_selCombo.pack(side=\"top\", fill=tk.BOTH)\n",
    "    \n",
    "\n",
    "        #Create display for current motor values\n",
    "        self.curr_motor_val=tk.StringVar()\n",
    "        self.curr_motor_valLabel=ttk.Label(self._frame2, textvariable=self.curr_motor_val)\n",
    "        self.curr_motor_valLabel.pack(side=\"top\", fill=tk.BOTH)\n",
    "\n",
    "         # Create LabelFrame for diodes\n",
    "        self.frame3=tk.LabelFrame(self._frame2, height=150, text=\"Diodes\")\n",
    "        self.frame3.pack(side=tk.TOP, fill=tk.X, expand=0, anchor=tk.NW)\n",
    "        self.frame3.config(highlightcolor='blue', highlightthickness=5, highlightbackground='blue', labelanchor=\"nw\")\n",
    "\n",
    "        #Create LabelFrame for camera\n",
    "        self.frame5=tk.LabelFrame(self._frame2, height=150, text=\"Cameras\")\n",
    "        self.frame5.pack(side=tk.TOP, fill=tk.X, expand=0, anchor=tk.NW)\n",
    "        self.frame5.config(highlightcolor='blue', highlightthickness=5, highlightbackground='blue', labelanchor=\"nw\")\n",
    "\n",
    " \n",
    "class MotorPanel():\n",
    "    \"\"\" This class contains the show scan bettons and the entries for the motor positon.  #TODO: Boxes for soft limits for motos\"\"\"\n",
    "      \n",
    "    def __init__(self, root, guicontrol, model):\n",
    "        self.guicontrol=guicontrol\n",
    "        self._model=model\n",
    "        self.frame4=tk.Frame(root)\n",
    "        self.frame4.pack(side='top',fill=tk.BOTH, expand=1) \n",
    "        \n",
    "        self.entries = {}\n",
    "        self.entriesValues = {}\n",
    "        self.motor_input_label=[\"Start\", \"Stop\", \"Stepsize\"]  #hard coded, but extendable for software limits\n",
    "        self.motor_input_titleLabel={}\n",
    "        self.motor_inputTexts ={}\n",
    "\n",
    "        # Function to validate entries to the ttk.Entry \n",
    "        vcmd = (self.frame4.register(self.onValidate), '%P', '%s', '%S','%W')\n",
    "\n",
    "        for i, column in enumerate(self.motor_input_label):\n",
    "            self.motor_inputTexts[column] =tk.StringVar(value=column)\n",
    "            #self.motor_inputTexts[column].set(f\"{column}\") #default labels without units\n",
    "            self.motor_input_titleLabel[column] = ttk.Label(self.frame4, font=('Calibri', 13), textvariable=self.motor_inputTexts[column])\n",
    "            self.motor_input_titleLabel[column].grid(row=0, column=i, sticky=\"nswe\")\n",
    "           \n",
    "\n",
    "            self.entriesValues[column]= tk.DoubleVar()\n",
    "            self.entries[column] = ttk.Entry(self.frame4, font=('Calibri', 13), textvariable=self.entriesValues[column], justify='left', validate=\"key\", validatecommand=vcmd)\n",
    "            self.entries[column].grid(row=1, column=i, sticky=\"nswe\")\n",
    "\n",
    "            \n",
    "        #lets create a push button\n",
    "        self.show_scan_settingsButton=ttk.Button(self.frame4,text=\"Show scan settings\")\n",
    "        self.show_scan_settingsButton.grid(row=2,columnspan=len(self.motor_input_label))\n",
    "\n",
    "\n",
    "    def onValidate(self, P, s, S, W):\n",
    "        \"\"\"This should validate the input for each ttk.Entry\n",
    "        %P = value of the entry if the edit is allowed\n",
    "        %s = value of entry prior to editing\n",
    "        %S = the text string being inserted or deleted, if any\n",
    "        %W = the tk name of the widget\n",
    "        \"\"\"\n",
    "        if P.strip() == \"\":\n",
    "            # allow blank string\n",
    "            return True\n",
    "        elif P.strip() == \"-\":\n",
    "            return True\n",
    "        elif P.strip() == \"+\":\n",
    "            return True\n",
    "        try:\n",
    "            float(P)\n",
    "            return True\n",
    "        except ValueError:\n",
    "            print(f'float({P}) raised ValueError in {W}.')\n",
    "            showwarning(title=f'ValueError in {W}', message=f\"{P} is not a valid input.\")\n",
    "            return False\n",
    "\n",
    "        # TODO\n",
    "        # Create entry limits for software limits\n",
    "      \n",
    "        \n",
    "    \n",
    "\n",
    "class Controller():\n",
    "    \"\"\"\" Controller part of the MVC model \"\"\"\n",
    "   \n",
    "    def __init__(self, model, view):\n",
    "        \n",
    "        self.model = model\n",
    "        self.view=view\n",
    "          \n",
    "        # Establish connection between buttons in View and controller\n",
    "        self.view.on_create_scanplot(self.create_scan_plot)\n",
    "        self.view.on_create_camplot(self.create_cam_plot)\n",
    "        self.view.on_clear(self.clear)\n",
    "\n",
    "        self.view.on_combobox_selection(self.motor_selection)\n",
    "\n",
    "        self.view.on_show_scan_settings(self.show_scan_settings)\n",
    "\n",
    "            \n",
    " \n",
    "    def clear(self, event):\n",
    "        \"\"\"\" Clears canvas on event action\"\"\"\n",
    "        self.view.ax0.clear()\n",
    "        self.view.canvas.draw()\n",
    "\n",
    "\n",
    "    def create_cam_plot(self, event):\n",
    "        \"\"\" 1D scan with a camera on event action \"\"\"\n",
    "\n",
    "        # get scan configuration\n",
    "        scan_dict=self.prepare_1d_scan_settings()\n",
    "\n",
    "        # get camera selected, dict\n",
    "        cam_sel_dict=self.view.get_camera_selection()\n",
    "        # get the keys\n",
    "        cam_selected=[k for k,v in  cam_sel_dict.items()]\n",
    "        num_dio_sel=len(cam_selected)\n",
    "        print(f\"Selected cameras for scan are {cam_selected}.\")\n",
    "        print(scan_dict, cam_sel_dict)\n",
    "\n",
    "        #clear graph\n",
    "        self.view.ax0.clear()\n",
    "        self.view.canvas.draw()\n",
    "\n",
    "        x_values=[]\n",
    "        for pos in scan_iter(scan_dict[\"mot_sel\"], scan_dict[\"Start\"], scan_dict[\"Stop\"], scan_dict[\"Stepsize\"], cb=None, show_progress=True):\n",
    "            \n",
    "            #save motor positions\n",
    "            x_values.append(pos)\n",
    "            for i in cam_selected:\n",
    "                img = self.model.cameras[i].get()\n",
    "            self.view.plot_cam_1d_scan(mot_selected=scan_dict[\"mot_sel\"], cam_image=img, camera=cam_selected)\n",
    "\n",
    "\n",
    "    \n",
    "    def prepare_1d_scan_settings(self):\n",
    "        \"\"\" Retrieves relevant information for scan and prepapres scan dict for output (1D scan)\"\"\"\n",
    "\n",
    "        mot_selected, scan_values=self.view.retrieve_scan_settings()\n",
    "\n",
    "        #[\"Start\", \"Stop\", \"Stepsize\"]\n",
    "        start= scan_values[\"Start\"].get()\n",
    "        stop= scan_values[\"Stop\"].get()\n",
    "        stepsize= scan_values[\"Stepsize\"].get()\n",
    "       \n",
    "        #check\n",
    "        try:\n",
    "            if stepsize > np.absolute(stop - start):\n",
    "                raise ValueError(\"Stepszie larger than total scan range.\")\n",
    "            \n",
    "        except ValueError as e:\n",
    "            showwarning(title='Stepsize too large.', message=\"Stepszie larger than total scan range.\")\n",
    "            return\n",
    "\n",
    "        try:\n",
    "            if start > stop:\n",
    "                raise ValueError(\"Start>Stop\")\n",
    "        except ValueError as e:\n",
    "            showwarning(title=\"Start>Stop\", message=\"Please select start < stop.\")\n",
    "\n",
    "        try:\n",
    "            if stepsize < 0:\n",
    "                raise ValueError(\"Stepsize negative.\")\n",
    "\n",
    "        except ValueError as e:\n",
    "            showwarning(title=\"Stepsize negative.\" , message=\"Choose positive Stepsize.\") \n",
    "        \n",
    "        try:\n",
    "            if stepsize==0:\n",
    "                raise ValueError(f\"Stepsize is {stepsize}\")\n",
    "        except ValueError as e:\n",
    "            showwarning(title=f\"Stepsize {stepsize}.\" , message=\"Choose different Stepsize.\") \n",
    "        \n",
    "        \n",
    "        scan_dict={}\n",
    "        scan_dict[\"mot_sel\"]=mot_selected\n",
    "        scan_dict[\"Start\"]=start\n",
    "        scan_dict[\"Stop\"]=stop\n",
    "        scan_dict[\"Stepsize\"]=stepsize\n",
    "        return scan_dict\n",
    "\n",
    "    def create_scan_plot(self, event):\n",
    "        \"\"\" Procedure for the 1D scan plot with diodes \"\"\"       \n",
    "        #get the diodes\n",
    "        dio_selected_dict=self.view.get_diode_selection()\n",
    "\n",
    "        # get the keys\n",
    "        dio_selected=[k for k,v in  dio_selected_dict.items()]\n",
    "        num_dio_sel=len(dio_selected)\n",
    "        print(f\"Selected diodes for scan are {dio_selected}.\")\n",
    "       \n",
    "        # get scan configuration\n",
    "        scan_dict=self.prepare_1d_scan_settings()\n",
    "\n",
    "        #clear graph\n",
    "        self.view.ax0.clear()\n",
    "        self.view.canvas.draw()\n",
    "\n",
    "\n",
    "        # prepare for plot\n",
    "        #self.view.modify_1d_plot(self.model.motors[mot_selected], dio_selected)\n",
    "        #self.view.modify_1d_plot(mot_selected, dio_selected)\n",
    "                  \n",
    "        x_values=[]\n",
    "        diode_values = [[] for i in range(0, num_dio_sel)]\n",
    "\n",
    "        # Pseudo exectuition of motor\n",
    "        #for pos in scan_iter(self.model.motors[mot_selected], start, stop, stepsize, cb=None, show_progress=False):\n",
    "        for pos in scan_iter(scan_dict[\"mot_sel\"], scan_dict[\"Start\"], scan_dict[\"Stop\"], scan_dict[\"Stepsize\"], cb=None, show_progress=True):\n",
    "            \n",
    "            #save motor positions\n",
    "            x_values.append(pos)\n",
    "            # read out and save diode positions\n",
    "            for i in range(num_dio_sel):\n",
    "                diode_values[i].append(self.model.diodes[dio_selected[i]].get())\n",
    "                #print(dio_selected[i])\n",
    "                #print(self.model.diodes[dio_selected[i]])\n",
    "\n",
    "            # this is the function that sends data for plotting to view\n",
    "            self.view.plot_1d_scan(mot_selected=scan_dict[\"mot_sel\"],dio_selected=dio_selected, mot_values=x_values, dio_values=diode_values)\n",
    "            \n",
    "            #nope this does not work?\n",
    "            #update motor position on GUI:\n",
    "            #self.view.update_current_motor_pos(scan_dict[\"mot_sel\"])\n",
    "            # I think this is where you need threading\n",
    "\n",
    "        #TODO: \n",
    "        # move motor per step and read out at every step\n",
    "        # if I had better access to the scan function, this whole function would be nicer \n",
    "\n",
    "\n",
    "    def motor_selection(self, event):\n",
    "        \"\"\" Selects motors on event action \"\"\"\n",
    "        # this method is directly bound to the function, so we can make use of this option\n",
    "        mot_selected = event.widget.get()\n",
    "        #show the current motor value after selection in the GUI\n",
    "        self.view.on_motor_selection(mot_selected)\n",
    "\n",
    "\n",
    "    def show_scan_settings(self, event):\n",
    "        \"\"\" Show scan settings on event action\"\"\"\n",
    "        self.view.show_scan_settings()\n",
    "\n",
    "\n",
    "def main():\n",
    "    \"\"\" Setting the stage for the GUI action \"\"\"\n",
    "    # create model and add diodes, motors, camera\n",
    "    # TODO: hide adding of motors in Model?\n",
    "    model = Model()\n",
    "    motors = {\"MY-LARGE-MOTOR\": \"m\", \"MY-TINY-MOTOR\": \"nm\", \"MY-NORMAL-MOTOR\": \"mm\"}\n",
    "    for motor_name, units in motors.items():\n",
    "        model.add_motor(motor_name, units)\n",
    "   \n",
    "    diodes = {\"INTENSITY\": None, \"COUNTER\": None, \"SIGNAL\": None, \"XRF\": None} \n",
    "    for diode_name in diodes.keys():\n",
    "        model.add_diode(diode_name) \n",
    "\n",
    "    cameras = {\"MY-CAMERA\": None}\n",
    "    for camera_name in cameras.keys():\n",
    "        model.add_camera(camera_name)\n",
    "\n",
    "    # prepare GUI\n",
    "    view = View(model)\n",
    "   \n",
    "\n",
    "    # inject into Controller\n",
    "    c = Controller(model, view)\n",
    "   \n",
    "    # start the GUI\n",
    "    view.run()\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from toydaq import Motor, Diode, Camera, scan_iter\n",
    "from tqdm import tqdm\n",
    "\n",
    "\n",
    "mot1=Motor(\"mot1\").name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mThe Kernel crashed while executing code in the the current cell or a previous cell. Please review the code in the cell(s) to identify a possible cause of the failure. Click <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. View Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
     ]
    }
   ],
   "source": [
    "import tkinter as tk\n",
    "root=tk.Tk()\n",
    "root."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.5 ('psi')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.5"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "6f9cbbd4473a438b4078c3ee0d5169810656479b939dec2c505a700ad036975e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}