Test Engineers Resource

Python – A version of Producer Consumer Pattern with Queues and Threading – Simulated Temp Chamber Demo

Posted on May 16, 2023 by LV_TS_Test_Engineer_3000_VI

Presentation on a version of producer consumer pattern using queues and threading.

Used Python,tkinter, and Matplotlib

Presentation is followed with a short video and zip code

May17,2023 added the Ipython console output image on post so you can see the thread stopping at window close.

Presentation

Other Info

On window close(x) you can see the three thread stop

Short Video about 50sec

python code zip

Python Producer-Consumer Pattern_v23 Download

Notes

Presentation: A Producer consumer type pattern , using temperature chamber testing as example (temperature, ps, uut are simple simulator for demo.)
Programming Language used: Python 3.9 in Spyder5.4.3,Matplotlib 3.7.1
Presentation app: Microsoft’s PowerPoint
Helpful resource: Stackoverflow, Search Engines , Bing chat AI, and Python communities.
Bing is a Microsoft’s product.
Python, Tkinter, and Matplotlib are products of respective company
Presentation shown to spark ideas of use.
This presentation is not connected to or endorsed by any company.
Use at your own risk.
Tags: Python, Python3.9, Tkinter , Matplotlib ,GUI, List, StringVar, Simulated Temperature chamber Testing, Threading,Queues
Title: Python – A version of Producer Consumer Pattern with Queues and Threading – Simulated Temp Chamber Demo

Posted in Arduino(r), Python, Test Sector, tkinter | Tagged Matplotlib, Producer Consumer Pattern, Python, Python 3.9, Queues, Temperature Chamber simulation, Threading, tkinter | Leave a comment

InProcess: Python – A version of Producer Consumer Pattern

Posted on May 11, 2023 by LV_TS_Test_Engineer_3000_VI

Python Tkinter and Matplotlib. Still working on it , but this is a preview

Using more Classes and Threads the video below is at normal speed (running a quick temp chamber profile. Most temperature profile don’t run this fast in real because temperature change is a slow process , but for the video and my viewer running faster profile. Currently plotting is adding 100ms Plot redraw. Working on it. (I am using “canvas.draw_idle()” which is faster than “canvas.draw()”) . Its the StringVar() variable are a bit blocking. Spend alot of time on the matplotlib section.

Classes

Temperature Chamber (simulated)
Power Supply(simulated)
UUT(simulated)
Sequence (to be added)

Short Video 60sec

Without updating the center Profile section and DegC in label tkinter StringVar (very fast) 14sec video

With the Profile and DegC StringVar() variables updating the Label in the center of the gui 60sec video

Notes

Presentation: In-process, A version of Producer Consumer type pattern (with classes and threading)
Programming Language used: Python 3.9 in Spyder 5.4.3,Matplotlib 3.7.1
Presentation app: Microsoft’s PowerPoint
Help support: StackOverFlow, search engines, and yes the new Bing Chat-AI engine.
Bing mention is a Microsoft Product.
Python and Tkinter are products of respective company
Presentation shown to spark ideas of use.
This presentation is not connected to or endorsed by any company.
Use at your own risk.
Tags: Python, Python3.9, Tkinter , Canvas ,GUI, List, StringVar, ListSelect, Classes, Threading. A producer consumer type pattern.

Thank you to all my viewer and support from the python communities

Posted in Test Sector | Tagged A version of Producer Consumer, GUI, Matplotlib, Python 3.9, Temperature Chamber simulation, tkinter | Leave a comment

Tkinter GUI and (non-tk) Matplotlib shrinking the tk GUI

Posted on May 5, 2023 by LV_TS_Test_Engineer_3000_VI

Presentation on “my” journey to find a solution for the unexpected shrinking of the Tkinter GUI when making a plot.

Notes

Presentation: Tkinter GUI with external non-Tkinter Matplotlib plot – the issue- Tkinter GUI was shrinking when Matplotlib plot created, I am using spyder with ipython for development
Programming Language used: Python 3.9 in Spyder 5.4.3,Matplotlib 3.7.1 my adventure to find a solution .
Lot of thanks to the python community, Stackoverflow of course, and search engine and Ai engines.
Presentation app: Microsoft’s PowerPoint
Window 10 : a Microsoft Product
Python ,Tkinter and Matplotlib are products of respective company.
Presentation shown to spark ideas of use.
This presentation is not connected to or endorsed by any company.
Use at your own risk.
Tags: Python, Python3.9, Tkinter , Matplotlib, Shrinking Tkinter GUI, SetProcessDpiAwareness(0)

Thanks to all the python communities and my viewers

Posted in Test Sector | Tagged "ctypes.windll.shcore.SetProcessDpiAwareness(0)", Matplotlib, Python, Python3.9, tkinter, Tkinter GUI and (non-tk) Matplotlib shrinking the tk GUI, tkinter shrinking when matplotlib plots | Leave a comment

Python – Sequence Editor example

Posted on May 1, 2023 by LV_TS_Test_Engineer_3000_VI

a Python tkinter Sequence Editor example with a simple UUT(Magnetic crane in canvas)

Presentation

Short Video of Sequence Editor with sequence running aprox 18sec

Python code text

# -*- coding: utf-8 -*-
"""
Created on Thu Apr 20 11:16:31 2023

@author: aleja

App: Sequence Editor (a simplified one level Sequence editor)
Plan: Use a previous app to create the Sequence Editor
      1) Command List with tab section
      2) A List to hold the Sequence being created
      3) Some button to Move command to Sequence List
      4) create some simplified UUT(something to control with the sequence list)
Window layout
 MainWindow
   TopFrame(title and company labels)
  Frame1(command list), LeftFrame(Sequence List),TopFrame (simulated UUT to test out sequence)

      

"""

#from tkinter import *
import tkinter as tk
import tkinter.ttk as ttk
#import math
import time
#import threading
import webbrowser



class MyApp:
    def __init__(self,tk):
        #GUI setup below
        self.myWindow=tk.Tk()
        self.myWindow.title("myWindow-SequenceEditor GUI")
        w_w=920
        w_h=400
        self.myWindow.minsize(w_w,w_h)
        #self.myWindow.maxsize(w_w,w_h)   #fix widow size
        
        
        
        # if you ever notice that some frame is sticking to bottom look at these setting
        self.myWindow.grid_rowconfigure(1,weight=1) #dont want top row frame to grow(row=0)
        self.myWindow.grid_columnconfigure(2,weight=1)
        self.myWindow.configure(background='gray')
 
        self.SearchEngine=""      

    def mainloop(self):
        tk.mainloop()
    
    def MakeFrames(self):
        
        #Top         
        self.TopFrame=tk.Frame(self.myWindow,width=100,height=100,bg='lightblue')
        self.TopFrame.grid(row=0, column=0, sticky='NESW', padx=10, pady=10, columnspan=3) #spans 3 cols (3 frames row1)
        self.TopFrame.rowconfigure(0,weight=1)
        self.TopFrame.columnconfigure(0,weight=1) #the lastcol goes along with rigth side expanding
                
        row1Height=300
        self.LeftFrame=tk.Frame(self.myWindow,width=300,height=row1Height,bg='lightblue')
        self.LeftFrame.grid(row=1, column=0, sticky='NWS', padx=(10,10), pady=(0,10), columnspan=1,rowspan=3) #padding ALSO takes two arguments tuple
        self.LeftFrame.rowconfigure((1,2,3),weight=1)
        self.LeftFrame.columnconfigure((0,1,2),weight=1) #the lastcol goes along with rigth side expanding
  
        self.CenterFrame=tk.Frame(self.myWindow,width=200,height=row1Height,bg='lightblue')
        self.CenterFrame.grid(row=1, column=1, sticky='NWES', padx=(0,0), pady=(0,10), columnspan=1,rowspan=3) #padding ALSO takes two arguments tuple
        self.CenterFrame.rowconfigure((1),weight=1)
        self.CenterFrame.columnconfigure((1),weight=1) #the lastcol goes along with rigth side expanding


        #some UUT to control with sequence sim frame
        self.RightFrame=tk.Frame(self.myWindow,width=350,height=row1Height,bg='lightblue')
        self.RightFrame.grid(row=1, column=2, sticky='NEWS', padx=(10,10), pady=(0,10), columnspan=1,rowspan=3) #padding ALSO takes two arguments tuple
        self.RightFrame.rowconfigure(1,weight=1)
        self.RightFrame.columnconfigure(2,weight=1) #the lastcol goes along with rigth side expanding




    def TopFrameWidget(self,strAppTitle="YourAppTitle",strAppCompany="YourCompanyName"):
        self.AppTitle=strAppTitle
        self.AppCompany=strAppCompany
        #TopFrame info
        AppTitleLabel=tk.Label(self.TopFrame, width=100, text=self.AppTitle)
        CompanyName=tk.Label(self.TopFrame, text=self.AppCompany)
        AppTitleLabel.grid(row=0, column=0, padx=10, pady=10, columnspan=2) #span 2 so it does not affect component button
        CompanyName.grid(row=0, column=3, padx=10, sticky='E') #Keep
        
    # Notebook add so this is only title and key words.
    #in a bigger app this will be loaded from your own file but I need it to be self contain for demo
    def Show_Keyword_Selection_ListBox(self):
        self.List_Of_Commands=["MoveLeft","MoveRight","MoveUp","MoveDown",\
                              "MagnetOn","MagnetOff","Reset"]  #The List of choices possible to get list from a file but demo is only this file

        self.List_Of_Actions=["AlarmLightOn","AlarmLightOff"]  #The List of choi            
 
        #add your tab list here
        self.LOKW_List=[self.List_Of_Commands,self.List_Of_Actions] 
            
        self.List_Of_Keyword_Var=tk.StringVar(value=self.List_Of_Commands) # you can put the starting list in StringVar
        
   
        #Sequence Title
        KW_Sel_LBox_Title=tk.Label(self.LeftFrame,text="Command Selection",bg='lightblue')
        KW_Sel_LBox_Title.grid(row=0,column=0,padx=10,pady=(10,0),sticky="N")
  
  
        
    def Show_Move_To_Right_Button(self):
       
        MovToRight_btn=tk.Button(self.LeftFrame,text="--->",command=lambda:self.Add_To_Query())
        #print(self.KW_Sel_LBox.curselection())
        MovToRight_btn.grid(row=1,column=1,padx=10,pady=10)
        #self.KW_Sel_LBox.focus()
        #self.KW_Sel_LBox.select_set(0,0)

    def Seq_Clicked(self,event=None):
        print(str(event))
        print("Seq_Clicked")
        #Test if Empty
        SeqListIndex=self.Seq_Lb.curselection()
        if (SeqListIndex):
            print("something is blue")
            self.action_mode.set("Seq_Selected")
        else:
            self.action_mode.set("Seq_Bottom")
            
    
    def Show_Sequence(self):
        self.Seq_Lb=tk.Listbox(self.CenterFrame,width=15,height=10,font=("Arial",14,''))
        self.Seq_Lb.bind("<<ListboxSelect>>",self.Seq_Clicked)
        self.Seq_Lb.grid(row=0,column=0,columnspan=2,rowspan=3,sticky='NWS',padx=10,pady=(20,10))
        self.Seq_Lb.columnconfigure(0,weight=1)
        self.Seq_Lb.rowconfigure(0,weight=1)     
        #attach a Scrollbar to txt1
        vscroll=tk.Scrollbar(self.CenterFrame,orient='vertical',command=self.Seq_Lb.yview)
        self.Seq_Lb['yscroll']=vscroll.set
        vscroll.grid(row=0,column=0,columnspan=2,rowspan=3,sticky='NSE',padx=10,pady=(20,10))
        

    # #move to seq list button
    # def Show_Move_Down_Right_Button(self):       
    #     MovTo_Down_btn=tk.Button(self.LeftFrame,text="|\n|\nV",command=lambda:self.Add_Q_To_Query())
    #     MovTo_Down_btn.grid(row=1,column=2,padx=10,pady=10)
    #     self.KW_Sel_LBox.focus()
    #     self.KW_Sel_LBox.select_set(0)
        
       
    def Add_To_Query(self):
        tab_index=self.tab_Holder.index('current')   # a way to get the index of tab selected    
        print(self.tab_Holder.tab(self.tab_list[tab_index],"text")) # a way to get selected tab name
        #print(self.scrollv_text_list[tab_index].curselection())
        self.KW_Sel_LBox=self.scrollv_text_list[tab_index]  
        IndexsList=list(self.KW_Sel_LBox.curselection())  #tuple to list (incase LBox is multiselect future)
        #print(IndexsList)
        if IndexsList:  #only if something in list
            for Index in IndexsList:                #for now only select one item at a time
             strText=self.KW_Sel_LBox.get(Index)
            #NO Delete  self.KW_Sel_LBox.delete(Index)
            #self.KW_Sel_LBox.selection_clear(0,'end') #way to clear all(no blue)
            #self.KW_Sel_LBox.selection_set(0)    #set to top of list
            
            #self.strText_KW=self.strText_KW+strText
            print(self.action_mode.get())
            if (self.action_mode.get()!="SingleStepRun"):
                Seq_IndexList=list(self.Seq_Lb.curselection())  #tuple to list   only one since multiselect not on
                if (Seq_IndexList): #someone select in seq list
                  for SeqIndex in Seq_IndexList:
                      self.Seq_Lb.insert(SeqIndex,strText)
                else:      
                  self.Seq_Lb.insert('end',strText)
                  self.Seq_Lb.see('end') #move scroll to end
            else:
                self.SingleStepRunCmd=strText
                print(self.SingleStepRunCmd)
                self.Run_Seq(True)


    def Show_Clear_Button(self):
        self.Clr_btn=tk.Button(self.CenterFrame,text="Clear Seq?",command=lambda:self.ClrQuery())
        self.Clr_btn.grid(row=3,column=0,padx=10,pady=(10,20),sticky="N")
        self.Clr_btn.rowconfigure(3,weight=1)

    def ClrQuery(self):
        print(self.myWindow.winfo_width(),self.myWindow.winfo_height())
        self.strText=""
        self.strText_KW=""
        self.Seq_Lb.focus()
        self.Seq_Lb.delete(0,'end')
        self.Seq_Lb.selection_clear(0,'end')
        
    def Delete_Selected_SeqList(self):
        IndexsList=list(self.Seq_Lb.curselection())  #tuple to list (incase LBox is multiselect future)
        #print(IndexsList)
        if IndexsList:  #only if something in list selected
            for Index in IndexsList:                #for now only select one item at a time
             self.Seq_Lb.delete(Index)        
            
    def Show_Del_Button(self):
        self.Del_btn=tk.Button(self.CenterFrame,text="Del Sel",command=lambda:self.Delete_Selected_SeqList())
        self.Del_btn.grid(row=3,column=1,padx=10,pady=(10,20),sticky="N")
        self.Del_btn.rowconfigure(3,weight=1)        

    def Show_RunSeq_Button(self):
        self.Clr_btn=tk.Button(self.CenterFrame,text="Run Seq",command=lambda:self.Run_Seq())
        self.Clr_btn.grid(row=3,column=2,padx=10,pady=(10,20),sticky="N")
        self.Clr_btn.rowconfigure(3,weight=1)

    
    def Run_Seq(self,SingleStepMode=False):
        self.Seq_Lb.focus()
        print (self.Seq_Lb.get(0,"end"))
        #self.Seq_List=list(self.Seq_Lb.get(0,"end"))
        if(SingleStepMode==False):
          self.Seq_List=list(self.Seq_Lb.get(0,"end"))
        else:
          self.Seq_List=[]  
          self.Seq_List.append(self.SingleStepRunCmd)  
            
        
        for i,item in enumerate(self.Seq_List):
            self.Seq_Lb.select_set(i)
            if (item=="MoveLeft" and self.Stop_Move_Left==0): 
                if(self.Magnet_Field==1 and self.Magnet_Ball==1):self.Move_Left()
                print(self.Magnet_Field)
                self.Move_Magnet_Left()
                self.Move_Chain_Left()
                if(self.Magnet_Field==1):
                    self.Magnet_On()
                
            if (item=="MoveRight" and self.Stop_Move_Right==0):
                if(self.Magnet_Field==1 and self.Magnet_Ball==1):self.Move_Right()
                self.Move_Magnet_Right()
                self.Move_Chain_Right()
                if(self.Magnet_Field==1):
                    self.Magnet_On()
                
            if (item=="MoveUp"):
                self.Stop_Move_Down=0
                self.Stop_Magnet_Down=0
                if(self.Magnet_Field==1 and self.Magnet_Ball==1 and self.Stop_Move_Up==0):self.Move_Up()
                if(self.Stop_Magnet_Up==0):
                    self.Move_Magnet_Up()
                    self.Move_Chain_Up()
                if(self.Magnet_Field==1):
                    self.Magnet_On()
                
            if (item=="MoveDown"):
                self.Stop_Move_Up=0
                self.Stop_Magnet_Up=0
                if(self.Magnet_Field==1 and self.Magnet_Ball==1 and self.Stop_Move_Down==0):self.Move_Down()
                if(self.Stop_Magnet_Down==0):
                    self.Move_Magnet_Down()
                    self.Move_Chain_Down()
                if(self.Magnet_Field==1):
                    self.Magnet_On()
                
            if (item== "Reset"):  self.Move_Center()
            if (item=="MagnetOn"): self.Magnet_On()
            if (item=="MagnetOff"): self.Magnet_Off()
            if (item=="AlarmLightOn"):self.Alarm_Light(1)
            if (item=="AlarmLightOff"):self.Alarm_Light(0)
            self.myWindow.update()
            self.Seq_Lb.select_clear(i)
            time.sleep(0.05)   #simple for now 
            print(i,item)
            
        
     
    #used by Show_Tabs via notebook event
    def Tab_Changed_Event(self,event=None):
        print("Tab changed")
        tab_index=self.tab_Holder.index('current')   # a way to get the index of tab selected 
        self.KW_Sel_LBox=self.scrollv_text_list[tab_index]
        print(self.tab_Holder.tab(self.tab_Holder.select(),"text"))
        self.scrollv_text_list[tab_index].focus()
        self.scrollv_text_list[tab_index].selection_clear(0,'end')
        self.scrollv_text_list[tab_index].select_set(0)
    
        


    def Show_Tabs(self):
        self.tab_Holder=ttk.Notebook(self.LeftFrame,style='Custom.TNotebook',width=280,height=250)
        self.tab_Holder.grid(row=0,column=0,sticky='NS',columnspan=1,rowspan=3,padx=20,pady=30)
        self.tab_Holder.rowconfigure(1,weight=1)
        self.tab_Holder.columnconfigure(1,weight=1)
        
        #need to use newer way ,this is still old way dont need tab name just order in a List
        tab1=tk.Frame(self.tab_Holder)  #tab obj to notebook but not added yet
        tab1.columnconfigure(0,weight=1) #lessons learn You must tell tab object that thing inside can auto grow
        tab1.rowconfigure(0,weight=1)
        tab2=tk.Frame(self.tab_Holder)
        tab2.columnconfigure(0,weight=1)
        tab2.rowconfigure(0,weight=1)

        self.tab_list=[tab1,tab2] # for adding scroll text obj in each tab


        #self,tab_Holder.bind("<<NotebookTabChanged>>",tab_event_handler)
        self.tab_Holder.add(tab1,text="SequenceCommand_KW")
        self.tab_Holder.add(tab2,text="SequenceAction_KW")
        #self.tab_Holder.add(tab3,text="Other_KW")

        self.scrollv_text_list=[]
        
        for i,tab in enumerate(self.tab_list):     # enumerate Leason Learn cool
            txt1=tk.Listbox(tab,width=30,height=20,font=("Arial",14,''),exportselection =False)
            txt1.grid(row=0,column=0,columnspan=2,rowspan=3,sticky='NWES',padx=20,pady=(20,20))
            txt1.bind("<<ListboxSelect>>",self.Selected_Cmd)
            txt1.columnconfigure(0,weight=1)
            txt1.rowconfigure(0,weight=1)     
            #attach a Scrollbar to txt1
            vscroll=tk.Scrollbar(tab,orient='vertical',command=txt1.yview)
            txt1['yscroll']=vscroll.set
            vscroll.grid(row=0,column=1,sticky='NSE',padx=20,pady=20)
            self.scrollv_text_list.append(txt1)            
            for KW in self.LOKW_List[i]:
                txt1.insert('end',KW)
        self.tab_Holder.select(self.tab_list[0])    #default tab of notebook
        self.scrollv_text_list[0].focus()
        self.scrollv_text_list[0].select_set(0)
        self.tab_Holder.bind("<<NotebookTabChanged>>",self.Tab_Changed_Event)

    def Selected_Cmd(self,event=None):
        print("Command Selected")
        IndexsList=list(self.KW_Sel_LBox.curselection())
        if(IndexsList): #nothing selected dont do anything
            str_command=(self.KW_Sel_LBox.get(IndexsList))
            print(str_command)
            #List that required one arg
            OneArg_List=["MoveLeft","MoveRight","MoveUp","MoveDown"]  #future as possible arg tab
            #if(str_command in OneArg_List):
            #     print("required amount arg")
        


    def Show_SimUUT(self):
        
        UUT_Width=300
        UUT_Height=300
        Dot_Padding=10
        Center_Dot_x=UUT_Width/2+Dot_Padding
        Center_Dot_y=UUT_Height/2+Dot_Padding
        Center_Dot_radius=20
        self.Floor_y=UUT_Height-10
        
        self.canv1=tk.Canvas(self.RightFrame,width=UUT_Width+30, height=UUT_Height+30, bg='lightblue', bd=0, highlightthickness=0)
        self.canv1.grid(row=0, column=0, columnspan=1,padx=10,pady=10,sticky="NSEW")
        self.Ball=self.canv1.create_oval(Center_Dot_x-Center_Dot_radius,Center_Dot_y-Center_Dot_radius,\
                          Center_Dot_x+Center_Dot_radius,Center_Dot_y+Center_Dot_radius,fill='blue') 
        self.Ball_Reset=self.canv1.coords(self.Ball)

        #Magnet
        self.Magnet_Field=0 #0=off 1=on
        self.Stop_Move_Left=0
        self.Stop_Move_Right=0
        self.Stop_Move_Up=0
        self.Stop_Move_Down=0
        self.Stop_Magnet_Down=0
        self.Stop_Magnet_Up=0
        self.Magnet_Field=1
        
        
        self.Magnet_Width=50
        self.Magnet_Height=20
        self.Magnet_Top_short=30
        self.Magnet_X1=UUT_Width/2-Dot_Padding-Center_Dot_radius
        self.Magnet_Y1=UUT_Height/2-self.Magnet_Height-Center_Dot_radius/2
        
        self.Magnet_Ploy_List=[self.Magnet_X1+self.Magnet_Top_short,self.Magnet_Y1,\
                              self.Magnet_X1+self.Magnet_Width,self.Magnet_Y1,\
                              self.Magnet_X1+self.Magnet_Width+self.Magnet_Top_short,self.Magnet_Y1+self.Magnet_Height,\
                              self.Magnet_X1,self.Magnet_Y1+self.Magnet_Height]

        
        self.Magnet=self.canv1.create_polygon(self.Magnet_Ploy_List, fill="brown",outline="black")
        self.Magnet_Reset=self.canv1.coords(self.Magnet)
        #Top part of beam
        self.canv1.create_rectangle(10,10,300,20, fill='yellow',outline='black')
        #Left side vert beam
        self.canv1.create_rectangle(10,10,20,300, fill='yellow',outline='black')
        #chain
        self.Chain_Thick=10
        self.Chain=self.canv1.create_rectangle(150-self.Chain_Thick/2+10,10,150+self.Chain_Thick/2+10,120,fill='orange',outline='black')
        self.Chain_Reset=self.canv1.coords(self.Chain)
        
        
        
    def Move_Left(self):
        #almost sure thare a better way to enum this
        x1=0
        y1=1
        x2=2
        y2=3
        self.Ball_coords=self.canv1.coords(self.Ball)
        print(self.Ball_coords)
        self.Ball_coords[x1]=self.Ball_coords[x1]-10
        self.Ball_coords[x2]=self.Ball_coords[x2]-10
        self.canv1.coords(self.Ball,self.Ball_coords)
        #self.canv1.coords(self.Ball, 10,10 ,20,20)
        

        
    def Move_Right(self):
        #almost sure thare a better way to enum this
        x1=0
        y1=1
        x2=2
        y2=3
        self.Ball_coords=self.canv1.coords(self.Ball)
        print(self.Ball_coords)
        self.Ball_coords[x1]=self.Ball_coords[x1]+10
        self.Ball_coords[x2]=self.Ball_coords[x2]+10
        self.canv1.coords(self.Ball,self.Ball_coords)
        #self.canv1.coords(self.Ball, 10,10 ,20,20)        

    def Move_Up(self):
        #almost sure thare a better way to enum this
        x1=0
        y1=1
        x2=2
        y2=3
        self.Ball_coords=self.canv1.coords(self.Ball)
        print(self.Ball_coords)
        self.Ball_coords[y1]=self.Ball_coords[y1]-10  #remember up is down in cavs coord
        self.Ball_coords[y2]=self.Ball_coords[y2]-10
        self.canv1.coords(self.Ball,self.Ball_coords)
        #self.canv1.coords(self.Ball, 10,10 ,20,20)

    def Move_Down(self):
        #almost sure thare a better way to enum this
        x1=0
        y1=1
        x2=2
        y2=3
        self.Ball_coords=self.canv1.coords(self.Ball)
        print(self.Ball_coords)
        self.Ball_coords[y1]=self.Ball_coords[y1]+10
        self.Ball_coords[y2]=self.Ball_coords[y2]+10
        self.canv1.coords(self.Ball,self.Ball_coords)
        #self.canv1.coords(self.Ball, 10,10 ,20,20)        
    
    def Move_Center(self):
        #almost sure thare a better way to enum this
        x1=0
        y1=1
        x2=2
        y2=3
        self.canv1.coords(self.Ball, self.Ball_Reset)
        self.canv1.coords(self.Magnet,self.Magnet_Reset)
        self.canv1.coords(self.Chain,self.Chain_Reset)
        #Magnet
        self.Magnet_Field=0 #0=off 1=on
        self.Stop_Move_Left=0
        self.Stop_Move_Right=0
        self.Stop_Move_Up=0
        self.Stop_Move_Down=0
        self.Stop_Magnet_Down=0
        self.Stop_Magnet_Up=0
        self.Magnet_Field=1
        self.Magnet_Ball=1
        self.Light=0


    def Move_Magnet_Left(self):
        self.Magnet_coords=(self.canv1.coords(self.Magnet))
        Xs=[0,2,4,6]
        Ys=[1,3,5,7]
        if(self.Stop_Move_Left==0):
            for x in Xs:
                self.Magnet_coords[x]-=10
                if(self.Magnet_coords[x]<=20):self.Stop_Move_Left=1
            self.canv1.coords(self.Magnet,self.Magnet_coords)
            print("Magnet Position",self.Magnet_coords)
        self.Stop_Move_Right=0    
            
    def Move_Magnet_Right(self):
        self.Magnet_coords=(self.canv1.coords(self.Magnet))
        Xs=[0,2,4,6]
        Ys=[1,3,5,7]
        if(self.Stop_Move_Right==0):
            for x in Xs:
                self.Magnet_coords[x]+=10
                if(self.Magnet_coords[x]>=300):self.Stop_Move_Right=1
            self.canv1.coords(self.Magnet,self.Magnet_coords)
            print("Magnet Position",self.Magnet_coords)
        self.Stop_Move_Left=0              

    def Move_Magnet_Up(self):
        self.Magnet_coords=(self.canv1.coords(self.Magnet))
        Xs=[0,2,4,6]
        Ys=[1,3,5,7]
        
        for y in Ys:
            self.Magnet_coords[y]-=10
            if(self.Magnet_coords[y]<=30):
                self.Stop_Move_Up=1
                self.Stop_Magnet_Up=1
        self.canv1.coords(self.Magnet,self.Magnet_coords)
        self.Stop_Magnet_Down=0

    def Move_Magnet_Down(self):
        self.Magnet_coords=(self.canv1.coords(self.Magnet))
        Xs=[0,2,4,6]
        Ys=[1,3,5,7]
        for y in Ys:
           self.Magnet_coords[y]+=10
           if(self.Magnet_coords[y]>=240):
               self.Stop_Magnet_Down=1
               self.Stop_Move_Down=1
        self.canv1.coords(self.Magnet,self.Magnet_coords)
        self.Stop_Magnet_Up=0

    def Move_Chain_Left(self):
        x1=0
        y1=1
        x2=2
        y2=3
        self.Chain_coords=self.canv1.coords(self.Chain)
        self.Chain_coords[x1]-=10
        self.Chain_coords[x2]-=10
        self.canv1.coords(self.Chain,self.Chain_coords)

    def Move_Chain_Right(self):
        x1=0
        y1=1
        x2=2
        y2=3
        self.Chain_coords=self.canv1.coords(self.Chain)
        self.Chain_coords[x1]+=10
        self.Chain_coords[x2]+=10
        self.canv1.coords(self.Chain,self.Chain_coords)


    def Move_Chain_Up(self,amount=10):
        x1=0
        y1=1
        x2=2
        y2=3
        self.Chain_coords=self.canv1.coords(self.Chain)
        self.Chain_coords[y2]-=amount
        self.canv1.coords(self.Chain,self.Chain_coords) 
        
    def Move_Chain_Down(self,amount=10):
        x1=0
        y1=1
        x2=2
        y2=3
        self.Chain_coords=self.canv1.coords(self.Chain)
        self.Chain_coords[y2]+=amount
        self.canv1.coords(self.Chain,self.Chain_coords)            
        
        
    def Magnet_On(self):        
        self.Magnet_Field=1
        #self.Magnet_Ball=0   #not connected yet
        print("Magnet file is :",self.Magnet_Field)
        x1=0
        y1=1
        x2=2
        y2=3
        self.Magnet_coords=(self.canv1.coords(self.Magnet))
        Xs=[0,2,4,6]
        Ys=[1,3,5,7]
        self.Ball_coords=self.canv1.coords(self.Ball)
        print("ball",self.Ball_coords)
        print("Mag",self.Magnet_coords)
        i=1
        list_of_coords_moves=[]
        Magnet_coords_Ys=[]
        Magnet_coords_Xs=[]
        #need  to see if  ball is near magnet and near center
        self.Magnet_Field_Power=30
        for item in Ys:
            Magnet_coords_Ys.append(self.Magnet_coords[item])
        for item in Xs:
            Magnet_coords_Xs.append(self.Magnet_coords[item])
        #check if ball is near the magnet and near center
        while (any(y < self.Ball_coords[y1]-20  for y in Magnet_coords_Ys)
               and any((self.Ball_coords[y1]-y)<self.Magnet_Field_Power for y in Magnet_coords_Ys)
               and ((self.Ball_coords[x2]+self.Ball_coords[x1])/2-(max(Magnet_coords_Xs)+min(Magnet_coords_Xs))/2 < 5)):#must also be close
            self.Magnet_Ball=1
            print("Magnet_ has the ball",self.Magnet_Ball)
            if(any(y < self.Ball_coords[y1]-20 for y in Magnet_coords_Ys)): #slow down
                i=i-1.5 #some accel
            else:
                i=i-1.5
            print(i)    
            self.Ball_coords[y1]=self.Ball_coords[y1]+i
            self.Ball_coords[y2]=self.Ball_coords[y2]+i
            self.canv1.coords(self.Ball,self.Ball_coords)
            #print(self.Ball_coords)
            self.Ball_coords=self.canv1.coords(self.Ball)
            list_of_coords_moves.append(self.Ball_coords)
            time.sleep(0.1)
            self.myWindow.update()
        if(self.Magnet_Ball==1):
            self.Magnet_coords=(self.canv1.coords(self.Magnet))
            self.Ball_coords[y1]=self.Magnet_coords[7]
            self.Ball_coords[y2]=self.Magnet_coords[7]+40
            self.canv1.coords(self.Ball,self.Ball_coords)  #sometime coarse and fine fix
            
        print(*list_of_coords_moves,sep="\n")   #this way printed  correctly
        #self.canv1.coords(self.Ball, 10,10 ,20,20)         
                        
                
    def Magnet_Off(self):
        self.Magnet_Field=0
        self.Magnet_Ball=0
        print("Magnet file is :",self.Magnet_Field)
        #almost sure thare a better way to enum this
        x1=0
        y1=1
        x2=2
        y2=3
        
        self.Ball_coords=self.canv1.coords(self.Ball)
        print(self.Ball_coords)
        i=1
        list_of_coords_moves=[]
        while (self.Ball_coords[y2]<self.Floor_y):
            if(self.Ball_coords[y2]<(self.Floor_y-100)):
                i=i+1.5 #some accel
            else:
                i=i+0.5
            print(i)    
            self.Ball_coords[y1]=self.Ball_coords[y1]+i
            self.Ball_coords[y2]=self.Ball_coords[y2]+i
            self.canv1.coords(self.Ball,self.Ball_coords)
            #print(self.Ball_coords)
            self.Ball_coords=self.canv1.coords(self.Ball)
            list_of_coords_moves.append(self.Ball_coords)
            time.sleep(0.1)
            self.myWindow.update()
        print(*list_of_coords_moves,sep="\n")   #this way printed  correctly
        #self.canv1.coords(self.Ball, 10,10 ,20,20)    

    def Alarm_Light(self,AL_State):
         self.Light=0
         self.AL_State=AL_State
         if(self.AL_State==1 and self.Already_Blinking==0):
             print("Alarm Light On")
             self.canv1.itemconfigure(self.AlarmLight, fill="red")
             self.Alarm_Light_Blink()
         if(self.AL_State==0):
             print("Alarm Light Off")
             self.canv1.itemconfigure(self.AlarmLight, fill="black")
 
    def Alarm_Light_Blink(self): # must prevent calling two or you will get double up window.after
        if(self.AL_State==1):
          self.Already_Blinking=1
          if (self.Light==1):
              self.canv1.itemconfigure(self.AlarmLight, fill="red")
              self.Light=0
          else:
              self.canv1.itemconfigure(self.AlarmLight, fill="black")
              self.Light=1
          self.myWindow.after(1000,self.Alarm_Light_Blink)
        else:
          self.Already_Blinking=0
 
    def Show_Alarm_Light(self):
          AL_Dia=20
          AL_Loc_X=280
          AL_Loc_Y=20
          
          
          self.AlarmLight=self.canv1.create_oval(AL_Loc_X,AL_Loc_Y,AL_Loc_X+AL_Dia,AL_Loc_Y+AL_Dia,fill="black",outline="black")
          self.Already_Blinking=0
          
    def Seq_Macro(self):  #future
        Macro_Seq1=('Reset', 'AlarmLightOn', 'MagnetOff', 'MoveLeft', 'MoveLeft', 'MoveLeft', 'MoveLeft',\
                    'MoveLeft', 'MoveDown', 'MoveDown', 'MoveDown', 'MoveDown', 'MoveDown', 'MoveLeft',\
                    'MoveLeft', 'MoveDown', 'MoveDown', 'MoveDown', 'MoveDown', 'MoveRight', 'MoveRight',\
                    'MoveRight', 'MoveRight', 'MoveRight', 'MoveRight', 'MoveRight', 'MagnetOn')


    def Mode_Change(self):
        strM=self.action_mode.get()
        if(strM=="Seq_Bottom"):
            self.Seq_Lb.selection_clear(0,'end')
            print(strM)
        if(strM=="Seq_Selected"):
            print(strM)
        if(strM=="SingleStepRun"):           
            self.Seq_Lb.selection_clear(0,'end')
            print(strM)
        print("inside Mode_Change")

    def Show_Modes(self):
        Modes=["Seq_Bottom","Seq_Selected","SingleStepRun"]
        Modes=[
                ("Seq_Bottom","Seq_Bottom"),
                ("Seq_Selected","Seq_Selected"),
                ("<-SingleStepRun","SingleStepRun")]
        self.action_mode=tk.StringVar()
        for i,mode in enumerate(Modes):
            print(i,mode)
            m_rb=tk.Radiobutton(self.LeftFrame,text=mode[0],variable=self.action_mode,value=mode[1],command=lambda:self.Mode_Change())  #odd RADIOBUTTON show on tk but Radiobutton it should be
            m_rb.grid(row=i,column=2,rowspan=2)
        self.action_mode.set("Seq_Bottom")
            
            


            
class Basket():
       def __init__(self,mainGUI=MyApp,x=0,y=0): # if i did not add =MyApp then mainGUI.canv1 will help me find canv1
           super().__init__()  #dont really know what to do with this yet (in learning curve)
           self.mainGUI=mainGUI #(yes i feel i am not doing it corretly or easier, had to do this why so other method of this class could see the arg mainGUI , maybe this is the way
           self.Basket_X1=x
           self.Basket_Y1=y
           self.Basket_W=76
           self.Basket_H=50
           self.Basket_Rim_H=10
           self.canvas=mainGUI.canv1 #feeling i should not do it this way (now this class need to know about other class canvas what if multiple canvas)
           self.Basket_coords=[self.Basket_X1,self.Basket_Y1,self.Basket_X1+self.Basket_W,self.Basket_Y1+self.Basket_Rim_H]
           self.canvas.create_rectangle(self.Basket_coords,fill="orange")
           self.BK_Under_RimY1=self.Basket_Y1+self.Basket_Rim_H
           #wire mesh of basket
           self.Basket_Border=1
           #verticle mesh |
           for Bx in range(self.Basket_X1+self.Basket_Border,self.Basket_X1+self.Basket_Border+self.Basket_W+self.Basket_Border+1,5):
               self.canvas.create_line(Bx,self.BK_Under_RimY1+self.Basket_Border,Bx,self.BK_Under_RimY1+self.Basket_Border+self.Basket_H+2,fill='gray',width=2)
           #horizontal mesh -
           for By in range(self.Basket_Y1+2,self.Basket_Y1+self.Basket_H+3,5):
               self.canvas.create_line(self.Basket_X1+1,By+self.Basket_Rim_H,self.Basket_X1-1+self.Basket_W,By+self.Basket_Rim_H,fill='gray',width=2)

           #a place to put basket text in canv1 which is canvas in this class
           self.Ball_In_Basket=0
           self.canvas_Text=self.canvas.create_text(150,310,text="",anchor="w",justify='left')
               
       def Monitor_Basket_For_Ball_Drop(self):
              #did not know how to use the super so it know  about mainGUI in the init arg (sorry) so i had to create self.mainGUI
              x1=0
              y1=1
              x2=2  
              y2=3
              self.Ball_coords=self.canvas.coords(self.mainGUI.Ball)
              print("HELLO")#Main GUI ball
              print("ball in basket=",self.Ball_In_Basket)
              print(self.Ball_coords)
              if (
                      self.Ball_coords[x1]>self.Basket_X1 and self.mainGUI.Ball_coords[x2]<self.Basket_X1+self.Basket_W
                      and self.Ball_coords[y2]>self.Basket_Y1 and self.mainGUI.Magnet_Ball==0):
                print("Ball inside basket,Excellent")
                self.canvas.itemconfigure(self.canvas_Text, text= "Ball inside basket. Excellent")
                self.Ball_In_Basket=1
              else:
                self.Ball_In_Basket=0  
              if (self.Ball_In_Basket==0):
                    #print("no ball in basket yet")
                    self.canvas.itemconfigure(self.canvas_Text, text= "Can you get ball """"inside"""" the basket")                 
              self.mainGUI.myWindow.after(1000,self.Monitor_Basket_For_Ball_Drop)

                                      
         
         
         
            
            
            
            

def main():
    #start steps to of app      
    root=MyApp(tk)
    root.MakeFrames()
    root.TopFrameWidget("Sequence Editor-with Magnetic Crane as UUT","TestEngineerResource.com")
    root.Show_Keyword_Selection_ListBox()
    root.Show_Sequence()   
    root.Show_Move_To_Right_Button()
    root.Show_Clear_Button()
    root.Show_Tabs()
    root.Show_SimUUT()
    root.Show_Del_Button()
    root.Show_RunSeq_Button()
    root.Show_Alarm_Light()
    root.Alarm_Light(True)
    root.Move_Center()
    MyBasket=Basket(root, 220, 235)  #just want to start doing more classes , ball and magnet should be class also
    MyBasket.Monitor_Basket_For_Ball_Drop()  
    root.Show_Modes() 
    #last line in main
    root.mainloop()  
           
if __name__ =="__main__":
    main()

Download Python code

Python SequenceEditor_v9 Download

Notes

Presentation: Sequence editor GUI with a simple UUT (Magnetic Crane and ball)
Programming Language used: Python 3.9 in Spyder 5.4.3
Presentation app: Microsoft’s PowerPoint
Python and Tkinter are products of respective company
Presentation shown to spark ideas of use.
This presentation is not connected to or endorsed by any company.
Use at your own risk.
Tags: Python, Python3.9, Tkinter , Canvas ,GUI, List, Dictionary, StringVar, Calling, Event binding , ListSelect, Classes, Python Sequence Editor example. Magnetic Crane example, Listbox. radiobutton
Future possibilities (currently in this demo there is no file save of the sequence or reading of a save sequence to keep the demo self contain to one file(the script) but in actual use most likely a “save sequence” and “get sequence” will need to be added. Maybe something for you to do if needed.

Posted in Python, Test Sector, tkinter | Tagged Canvas, Classes, Listbox, Magnetic Crane GUI example, Python, Python Sequence Editor, tkinter | Leave a comment

Python – Analog Meter with New Chart-Class this time

Posted on April 19, 2023 by LV_TS_Test_Engineer_3000_VI

converted a previous python project over to Class type with new Chart /scope adventure

Short Video on GUI (tkinter)

Python Code Text (tkinter)

# -*- coding: utf-8 -*-
"""
Created on Tue Apr 18 06:52:07 2023

@author: aleja

Using Class with the Analog Meter and Chart

"""

#from tkinter import *
import tkinter as tk
import math
import time
import threading


class MyApp:
    def __init__(self,tk):
        #GUI setup below
        self.myWindow=tk.Tk()
        self.myWindow.title("myWindow-Analog Meter and Chart GUI")
        w_w=1000
        w_h=500
        self.myWindow.minsize(w_w,w_h)
        self.myWindow.maxsize(w_w,w_h)
        print(self.myWindow.winfo_x(),self.myWindow.winfo_y())
        #if you want to move the operator table to see rest of belt comment out
        #next time use resize=false,false
        
        # if you ever notice that some frame is sticking to bottom look at these setting
        self.myWindow.grid_rowconfigure(1,weight=1) #dont want top row frame to grow(row=0)
        self.myWindow.grid_columnconfigure(1,weight=1)
        self.myWindow.configure(background='gray')

    def mainloop(self):
        tk.mainloop()
    
    def MakeFrames(self):
        #Left side button and input
        self.frame1=tk.Frame(self.myWindow,width=120,height=300,bg='lightblue')
        self.frame1.grid(row=0, column=0, sticky='NSWE', padx=10, pady=10, columnspan=1,rowspan=2)
        self.frame1.rowconfigure(0,weight=1)
        self.frame1.columnconfigure(0,weight=0) #the lastcol goes along with rigth side expanding    

        #frame2  Right 
        # adjust r,c,sticky, row and column config as need
        self.frame2=tk.Frame(self.myWindow,width=350,height=350,bg='blue')
        self.frame2.grid(row=1, column=1, sticky='NESW', padx=(0,10), pady=(0,10), columnspan=1) #padding ALSO takes two arguments tuple
        self.frame2.rowconfigure(0,weight=0)
        self.frame2.columnconfigure(1,weight=0) #the lastcol goes along with rigth side expanding
        
        #Top frame
        self.frame3=tk.Frame(self.myWindow,width=100,height=100,bg='lightblue')
        self.frame3.grid(row=0, column=1, sticky='NESW', padx=(0,10), pady=10, columnspan=1) #padding ALSO takes two arguments tuple
        self.frame3.rowconfigure(1,weight=0)
        self.frame3.columnconfigure(1,weight=1) #the lastcol goes along with rigth side expanding

    def TopFrameWidget(self,strAppTitle="YourAppTitle",strAppCompany="YourCompanyName"):
        self.AppTitle=strAppTitle
        self.AppCompany=strAppCompany
        #frame3 info
        AppTitleLabel=tk.Label(self.frame3, width=100, text=self.AppTitle)
        CompanyName=tk.Label(self.frame3, text=self.AppCompany)
        AppTitleLabel.grid(row=0, column=0, padx=0, pady=10, columnspan=2) #span 2 so it does not affect component button
        CompanyName.grid(row=0, column=3, padx=10, sticky='E') #Keep

    def MakeAnalogMeter(self,width=300,height=300):
# ===============Meter_Info =================
        self.Meter_Width=width
        self.Meter_Height=height
        #Meter Povit Point Center Dot

        #Meter Povit Point Center Dot
        self.Dot_Padding=10
        self.Center_Dot_x=self.Meter_Width/2+self.Dot_Padding
        self.Center_Dot_y=self.Meter_Height/2+self.Dot_Padding
        self.Center_Dot_radius=10
        
        self.canv2=tk.Canvas(self.frame2,width=self.Meter_Width+30, height=self.Meter_Height, bg='lightblue', bd=0, highlightthickness=0)
        self.canv2.grid(row=0, column=0, columnspan=1,padx=20,pady=10)
        self.canv2.create_oval(self.Center_Dot_x-self.Center_Dot_radius,self.Center_Dot_y-self.Center_Dot_radius,\
                          self.Center_Dot_x+self.Center_Dot_radius,self.Center_Dot_y+self.Center_Dot_radius,fill='blue')
        self.Reading_Value2=self.canv2.create_text(self.Meter_Width/2-15,225,fill="black",text="",font=('Arial',20,''),anchor="center")

        #===  Two Arc for Major and Minor tick marks
        arcx=self.Center_Dot_x
        arcy=self.Center_Dot_y
        arc_circle_radius=100
        coord_arc=(arcx-arc_circle_radius,arcx-arc_circle_radius,\
                   arcx+arc_circle_radius,arcx+arc_circle_radius)
        arc_startDeg=0
        arc_endDeg=180
        self.canv2.create_arc(coord_arc,start=arc_startDeg,extent=arc_endDeg)
        
        arc_circle_radius=120
        coord_arc=(arcx-arc_circle_radius,arcx-arc_circle_radius,\
                   arcx+arc_circle_radius,arcx+arc_circle_radius)
        self.canv2.create_arc(coord_arc,start=arc_startDeg,extent=arc_endDeg)
        
        #=== create first starting Meter Pointer red arrow line
        MeterValue=0  #unscale 0-180
        Deg=MeterValue-90
        RadDeg=math.radians(Deg)
        line_length=115
        line_x=line_length * math.sin(RadDeg)
        line_y=line_length * math.cos(RadDeg)
        
         
        self.MeterPointer=self.canv2.create_line(self.Center_Dot_x,self.Center_Dot_y,self.Center_Dot_x+line_x,self.Center_Dot_y-line_y,fill='red',width=3,arrow='last')# remember y going up is less
        
        #======= Major and Minor ====== Tick markers
        #major line
        for iDeg in range(-90,91,10):   #because of axis  0-180  = -90 to 90
            RadDeg=math.radians(iDeg)
            subline_length=100
            subline_x1=subline_length * math.sin(RadDeg)
            subline_y1=subline_length * math.cos(RadDeg)
            subline_length=120
            subline_x2=subline_length * math.sin(RadDeg)
            subline_y2=subline_length * math.cos(RadDeg)
            self.canv2.create_line(self.Center_Dot_x+subline_x1,self.Center_Dot_y-subline_y1,\
                              self.Center_Dot_x+subline_x2,self.Center_Dot_y-subline_y2,fill='black',width=3)# remember y going up is less
        #minor line
        for iDeg in range(-90,91,2):
            RadDeg=math.radians(iDeg)
            subline_length=100
            subline_x1=subline_length * math.sin(RadDeg)
            subline_y1=subline_length * math.cos(RadDeg)
            subline_length=120
            subline_x2=subline_length * math.sin(RadDeg)
            subline_y2=subline_length * math.cos(RadDeg)
            self.canv2.create_line(self.Center_Dot_x+subline_x1,self.Center_Dot_y-subline_y1,\
                              self.Center_Dot_x+subline_x2,self.Center_Dot_y-subline_y2,fill='gray',width=1)# remember y going up is less

    def Update_Meter_MajorText(self,EngMin=0,EngMax=10):
        self.EngMin=EngMin
        self.EngMax=EngMax
        self.MaxDeg=180  #keep dont change for demo, it important for 180 deg display meter
        self.MinDeg=0    #Keep dont change for demo
        self.Meter_Text_Canv_List=[]
        """
        Updates the Meters Major Text Number
        """
        #Number text on Major ticks
        MeterNumMajor=0
        
        for iDeg in range(-90,91,10):
            MeterNumMajor=self.Deg_to_EngNum(iDeg+90)
            RadDeg=math.radians(iDeg)
            Text_Radius_Loc=140
            Text_x1=Text_Radius_Loc * math.sin(RadDeg)
            Text_y1=Text_Radius_Loc * math.cos(RadDeg)
            M_T_C=self.canv2.create_text(self.Center_Dot_x+Text_x1,self.Center_Dot_y-Text_y1,fill="black",text=round(MeterNumMajor,1),font=('Arial',9,''))
            self.Meter_Text_Canv_List.append(M_T_C)
            MeterNumMajor=MeterNumMajor+10

    def EngNum_to_Deg(self,EngNum):
        M_slope=((self.MaxDeg-self.MinDeg)/(self.EngMax-self.EngMin))
        Deg=M_slope*(EngNum-self.EngMin)
        return Deg
    
    def Deg_to_EngNum(self,Deg0_180):
        M_slope=((self.EngMax-self.EngMin)/(self.MaxDeg-self.MinDeg))
        EngNum=M_slope*(Deg0_180)+self.EngMin
        return EngNum

    def InputVerticalSlider(self):
        #binding keys and mouse
        #=== Veritical Slider used to change Meter Pointer (reading) ===============================
        self.MeasNum=tk.DoubleVar()  
        self.VSlider=tk.Scale(self.frame1,from_=self.EngMax, to=self.EngMin,length=150,variable=self.MeasNum,digits=3,resolution=0.1)
        self.VSlider.grid(row=0,column=0) #dont forget the odd underscore on from
        #Becasue the slider would generate tons of event using release and I DONT KNOW how have ,not found ScaleChanged event
        self.VSlider.bind('<ButtonRelease-1>',lambda event: self.Update_Meter(event,"Mouse Released"))
        #important <Up> is not equal to <KeyRelease-Up>  Up only was causing a missing event that cause a one resolution offset
        self.VSlider.bind('<KeyRelease-Up>',lambda event: self.Update_Meter(event,"Up key Pressed"))  #just using UP will give on missing event which cause odd 0.1 offest
        self.VSlider.bind('<KeyRelease-Down>',lambda event: self.Update_Meter(event,"Down key Pressed"))
        #Not working this way VSlider.bind('<ButtonRelease-1>,<Up>,<Down>',Update_Meter)
        self.VSlider.focus_set() #focus is important
        self.frame1.focus_force() #focus is important for demo so the frame will listen to the up and down keys both the keypad, and keyboard area
        #interesting ctrl and up key moved it in big steps, not the shift key the ctrl key

    def Buttons_Left_side(self):
        Button_side_Label=tk.Label(self.frame1,text="Sim_Input")
        Button_side_Label.grid(row=0,column=0,padx=10,pady=10,stick="N")
        
        Zero_VSlider_Btn=tk.Button(self.frame1, text='Min',width=15, command=lambda:self.Zero_Slider())
        Zero_VSlider_Btn.grid(row=1, column=0,padx=19,pady=2)  
        
        Zero_to_10_Btn=tk.Button(self.frame1, text='Eng(0-10)',width=15, command=lambda:self.Meter_and_Slider_Update(0,10))
        Zero_to_10_Btn.grid(row=2, column=0,padx=10,pady=2) 
        
        Zero_to_5_Btn=tk.Button(self.frame1, text='Eng(0-5)',width=15, command=lambda:self.Meter_and_Slider_Update(0,5))
        Zero_to_5_Btn.grid(row=3, column=0,padx=10,pady=2) 
        
        Four_to_20_Btn=tk.Button(self.frame1, text='Eng(4-20)',width=15, command=lambda:self.Meter_and_Slider_Update(4,20))
        Four_to_20_Btn.grid(row=4, column=0,padx=10,pady=2)
        
        N10_to_P10_Btn=tk.Button(self.frame1, text='Eng(N10-P10)',width=15, command=lambda:self.Meter_and_Slider_Update(-10,10))
        N10_to_P10_Btn.grid(row=5, column=0,padx=10,pady=2)  
        
        self.Clr_n_Sine_Btn=tk.Button(self.frame1, text='Clr and Sine',width=15, command=lambda:self.Thread_Call_Sine())
        self.Clr_n_Sine_Btn.grid(row=6, column=0,padx=10,pady=2)  

        self.Clr_Btn=tk.Button(self.frame1, text='Clear Plot',width=15, command=lambda:self.Clear_Plot_Lines())
        self.Clr_Btn.grid(row=7, column=0,padx=10,pady=2)  


    def RightSideCanvas(self):
        """ 
        Description: Right side canvas for text and chart use \n
        Arguments: no arg\n
        Other: \n
        Other: 
        """
        #=== Canvas 3
        # canv3 side info on Right
        self.canv3=tk.Canvas(self.frame2,width=self.Meter_Width, height=self.Meter_Height, bg='black', bd=0, highlightthickness=0)
        self.canv3.grid(row=0, column=1, columnspan=1,padx=20,pady=10)


    def Chart_Init(self,C_Width,C_Height):
        """ 
        Description: Initial Chart canvas with outer canvas \n
        Arguments: no arg\n
        Other: \n
        Other: 
        """
        self.Chart_Width=C_Width
        self.Chart_Height=C_Width
        #Graph Initialize
        self.List_Of_Points=[(0,self.Chart_Height),(0,self.Chart_Height)]
        self.Point_Sample_Index=0
        UnTuple=[a for x in self.List_Of_Points for a in x] #stackoverflow help credit "Python-tkiner How to create-line with multiple points P.C. answer
        self.Plot_Line=self.canv3.create_line(*UnTuple,fill='yellow',width=3)
        #print(UnTuple)
        #scope outer border canvas
        self.canv4=tk.Canvas(self.frame2,width=self.Chart_Width+100, height=self.Chart_Height+100, bg='lightgray', bd=1, highlightthickness=1)
        self.canv4.grid(row=0, column=1, columnspan=1,padx=20,pady=10)
        tk.Misc.lift(self.canv3)# stackoverflow help

    def Chart_Grid_Lines(self):
        #===== Chart Grid Line
        for x_div in range(11):
            self.canv3.create_line(x_div*self.Chart_Width/10,0,x_div*self.Chart_Width/10,self.Chart_Height,fill='green',width=2)
            print(x_div)
        for y_div in range(11):
            self.canv3.create_line(0,y_div*self.Chart_Height/10,self.Chart_Width,y_div*self.Chart_Height/10,fill='green',width=2)
        tk.Misc.lift(self.canv3)# stackoverflow 
        #move here to resolve text behind grid lines
        #some info on right side convas - Reading will get a value when updating vertical slider(called scale in python)
        self.Info_Label=self.canv3.create_text(10,0,fill="white",text="Use the mouse in demo \n to move the slider or \n the Up, Down keys",anchor='nw',font=('Arial',14,''))
        self.Reading_Value=self.canv3.create_text(50,100,fill="white",text="",font=('Arial',20,''),anchor="center")
        self.Event_Label_Info=self.canv3.create_text(10,150,fill="white",text="",font=('Arial',14,''))

    def Chart_Border_Text(self):
        self.Y_Chart_Text_List=[]
        for y_scope_text in range(11):
            self.Y_Chart_Text=self.canv4.create_text(40,y_scope_text*self.Chart_Height/10+50,text=str(self.EngMax-y_scope_text),font=('Arial',9,''))
            self.Y_Chart_Text_List.append(self.Y_Chart_Text)       
        for x_scope_text in range(11):
         self.canv4.create_text(x_scope_text*self.Chart_Width/10+50,self.Chart_Height+60,text=str(x_scope_text*30),font=('Arial',9,''))
        self.canv4.create_text(20,self.Chart_Height/2+50,text="Amplitude",angle=90,font=('Arial',12,''))
        self.canv4.create_text(self.Chart_Width/2+50,self.Chart_Height+80,text="Sample",font=('Arial',12,''))
        
        self.ChartTitle=self.canv4.create_text(self.Chart_Width/2+50,20,text="Your Chart Title",font=('Arial',12,'bold'))


    def Chart_Border_Text_Update(self):
        i=0
        Y_Div=(self.EngMax-self.EngMin)/10
        for Y_Chart_txt in self.Y_Chart_Text_List:
            self.canv4.itemconfigure(Y_Chart_txt,text=str(round(self.EngMax-Y_Div*i,1)))
            i+=1
 
    def Update_Chart_Title(self,strText=""):
        self.canv4.itemconfigure(self.ChartTitle,text=strText)
        
        
                   

    #button functions
    #==== Main Update of Meter Pointer
    def Update_Meter(self,event=None,EventMsg="NoMsg"): # I am a relative novice for this event obj arg , its in my learning curve,it did not hiddern this demo
        """ 
        Description: Update the Meters red pointer \n
        Arguments: arg event is tkinter obj when bind events, EventMsg is user string\n
        Other: currently Dont know how to use event object directly yet, so using EventMsg in this demo
        \nOther: using default None so i can use this function without event also.
        """
        self.Point_Sample_Index
    
        if event==None:
            #just a note to remind when a function call was made that as event=None
            str_note="reminder,Please note event arg was  empty so dont used it"
            #print(str_note)
        #Update the pointer on the meter
        #MeterValue=(MeasNum.get())
        self.MeterValue=self.MeasNum.get()  
        #VSlider.set(MeterValue)
        Deg=(self.EngNum_to_Deg(self.MeterValue))-90
        RadDeg=math.radians(Deg)
        line_length=115
        line_x=line_length * math.sin(RadDeg)
        line_y=line_length * math.cos(RadDeg)
        self.canv2.coords(self.MeterPointer,self.Center_Dot_x,self.Center_Dot_y,self.Center_Dot_x+line_x,self.Center_Dot_y-line_y)
        #canv2.create_line(Center_Dot_x,Center_Dot_y,Center_Dot_x+line_x,Center_Dot_y-line_y,fill='red',width=3,arrow='last')# remember y going up is less
        self.canv2.itemconfigure(self.Reading_Value2,text=str(round(self.MeterValue,3)),anchor='w')
        self.canv3.itemconfigure(self.Reading_Value,text=str(round(self.MeterValue,3)),anchor='w')
        self.canv3.itemconfigure(self.Event_Label_Info,text=str(EventMsg),anchor='w')
        #put Point in list
        if(self.EngMin==0):self.Scale_MeterValue=(self.Meter_Height/self.EngMax-self.EngMin) * self.MeterValue*(1)+self.Meter_Height/(self.EngMax-self.EngMin)*0  #leave at bottom -0
        if(self.EngMin<0):self.Scale_MeterValue=(self.Meter_Height/(self.EngMax-self.EngMin)) * self.MeterValue*(1)+self.Meter_Height/(self.EngMax-self.EngMin)*10  #ref up 10
        if(self.EngMin>0):self.Scale_MeterValue=(self.Meter_Height/(self.EngMax-self.EngMin)) * self.MeterValue*(1)+self.Meter_Height/(self.EngMax-self.EngMin)*-4  #ref down 4
        #so chart also update when meter called
        self.Chart_Border_Text_Update()
        self.Update_Chart_Plot()
 
    def Update_Chart_Plot(self):
         """ 
         Description: Updates the chart with scrolling left effect \n
         Arguments: no arg\n
         Other: \n
         Other: 
         """
         #==========chart style scroll left=================
         max_chart_points=self.Chart_Width
         if(self.Point_Sample_Index>max_chart_points): 
            self.List_Of_Points.pop(0)
            
            New_LOP=[]
            i=0
            for Point in self.List_Of_Points:
                #New_LOP
                #tuple are unchangeable (has no index)
                t_to_lst=list(Point)
                t_to_lst[0]=i  #to start shifting graph left(the x values=sample index)
                Point=tuple(t_to_lst)
                #print(Point)
                New_LOP.append(Point) #because point shift x  for each y it all new
                i=i+1
            self.List_Of_Points= New_LOP
            self.Point_Sample_Index=i
            
    
         self.List_Of_Points.append((self.Point_Sample_Index,self.Chart_Height-int(self.Scale_MeterValue)))
         self.Point_Sample_Index +=1
     
         UnTuple=[a for x in self.List_Of_Points for a in x] #stackoverflow help credit "Python-tkiner How to create-line with multiple points P.C. answer
         #self.canv3.delete(self.Plot_Line,'all') #seem to delete ALL "line type" even the grid lines,interesting
         self.canv3.delete(self.Plot_Line) #needed but not work complete working in thread completely
         self.Plot_Line=self.canv3.create_line(*UnTuple,fill='yellow',width=3)
         #print(UnTuple)   
         self.myWindow.update()
    



    def Zero_Slider(self):
        self.VSlider.focus_force
        if (self.EngMin<0):
            self.MeasNum.set(0)
        else:    
            self.MeasNum.set(self.EngMin)
        self.Update_Meter(None,"Min/Zero Button or Function Call") #warning not using event arg or in function 
        return


    def Meter_and_Slider_Update(self,Emin=0,Emax=10):
        """ 
        Description: Update Meter and Slider \n
        Arguments: Eng Min and Eng Max\n
        Other:Used when moving slider or changing range \n
        Other: 
        """        
        self.EngMax=Emax
        self.EngMin=Emin
        print(self.EngMin,self.EngMax)
        #first delete current text
        for M_T_C_item in self.Meter_Text_Canv_List:
            self.canv2.delete(M_T_C_item)
        self.Update_Meter_MajorText(self.EngMin,self.EngMax)
        self.VSlider.configure(from_=self.EngMax,to=self.EngMin)
        self.VSlider.focus_force
        if(self.EngMin<0):
           self.VSlider.set(0)
           self.MeasNum.set(0)
        else:
           self.VSlider.set(self.EngMin)
           self.MeasNum.set(self.EngMin)
        self.Update_Meter(None,"Button released:"+str(self.EngMin)+"--"+str(self.EngMax)) #warning not using event arg or in function
        #self.canv3.delete(self.Plot_Line)
        return

    def Thread_Call_Sine(self):
        threading.Thread(target=self.Clr_n_Sine,daemon=True).start() #remember no ()
        
    
    def Clr_n_Sine(self):
        #if real hardware connected must check sin amplitude for your application
        #demo sinewave
        self.Clr_n_Sine_Btn['state']='disabled'
        #print(MeterValue,MeasNum.get(),VSlider.get())
        self.VSlider.set(0)
        #also clear List of point
        self.Point_Sample_Index
        self.List_Of_Points=[(0,self.Chart_Height),(0,self.Chart_Height)] #need two points same at zero
        UnTuple=[a for x in self.List_Of_Points for a in x]
        self.canv3.delete(self.Plot_Line)
        if (self.EngMin<0):
            self.Num_Of_90s=7
            self.StartingPhase=-90
        else:
            self.Num_Of_90s=8
            self.StartingPhase=0
        for angle in range(self.StartingPhase,90*self.Num_Of_90s,1):
            #for amp 8
            #time.sleep(0.005)  #commented out to see full speed cpU% wil increase since not delay
            max_amp=(self.EngMax-self.EngMin)/2
            offset=(self.EngMax+self.EngMin)/2
            y=max_amp*math.sin(math.radians(angle-90))+offset
            x=5*math.cos(math.radians(angle))
            self.VSlider.focus_force
            self.MeasNum.set(y)
            self.Update_Meter(None,"sin function")
            #self.Update_Chart_Plot()
        print(angle)   
        self.Clr_n_Sine_Btn['state']='normal'
        self.Chart_Border_Text_Update()
        self.Zero_Slider() #zero out or min slider
        
    def Clear_Plot_Lines(self):
        self.VSlider.focus_force
        self.canv3.delete(self.Plot_Line)
        self.List_Of_Points.clear()    #Dont for the () ,yes i forget
        self.List_Of_Points=[(0,self.Chart_Height),((0,self.Chart_Height))]#but need min two point for create line
        self.Point_Sample_Index=0
        self.canv3.itemconfigure(self.Info_Label,text="")
        self.canv3.itemconfigure(self.Event_Label_Info,text="")







    
def main():
    #start steps to of app      
    root=MyApp(tk)
    root.MakeFrames()
    root.TopFrameWidget("Analog Meter Display and Chart","TestEngineerResource.com")
    root.MakeAnalogMeter(300,300)
    root.Update_Meter_MajorText(0,10)
    root.InputVerticalSlider()
    root.Buttons_Left_side()
    root.RightSideCanvas()
    root.Chart_Init(300,300)
    root.Chart_Grid_Lines()
    root.Chart_Border_Text()
    root.Update_Chart_Title("Chart Demo")
    
    #last line in main
    root.mainloop()  
           
if __name__ =="__main__":
    main()

Python – Analog Meter and Chart Download

Python_tkinter_class Chart_v4 Download

Notes

Presentation: Analog Meter Display and Chart GUI using Vertical slider for input to meter, show different scale changes
Programming Language used: Python 3.7 in Spyder
Presentation app: Microsoft’s PowerPoint
Python and Tkinter are products of respective company
Presentation shown to spark ideas of use.
This presentation is not connected to or endorsed by any company.
Use at your own risk.
Tags: Python, Python3.7, Tkinter , Canvas ,GUI, List, Dictionary, StringVar, Calling, Event binding , Default None for Event, Key and Mouse binding, KeyRelease-Up, KeyRelease-Down, Chart, sinewave

Posted in Python, Test Sector, tkinter | Tagged Analog Meter, Canvas, Class and Function, GUI, Python, Python Analog Meter and Chart, Python3.7, tkinter, Waveform Chart | Leave a comment

Python tkinter and time delay

Posted on April 17, 2023 by LV_TS_Test_Engineer_3000_VI

Presentation on Different ways to create time delay in tkinter

Short Video (about 35sec)

Python code Text

# -*- coding: utf-8 -*-
"""
Created on Sun Apr 16 11:41:30 2023

@author: aleja

Analog Meter GUI and Demo for learning

"""


from tkinter import *
#for some reason from tkinter.ttk import * cause bg lightblue error
#from tkinter.ttk import Combobox
#import math
import time
#import datetime
#import os    #for path filename join
import threading


#GUI setup below
myWindow=Tk()
myWindow.title("myWindow-Tkinter and TimeDelay GUI")
w_w=850
w_h=400
myWindow.minsize(w_w,w_h)
#myWindow.maxsize(w_w,w_h) #if you want to move the operator table to see rest of belt comment out
#next time use resize=false,false

# do this or frame (last frame row number, in window will not follow window (expanding)
myWindow.grid_rowconfigure(1,weight=1)  #Important This was the reason for  on frame being stuck at bottom was row 0 but 3frames
myWindow.grid_columnconfigure(1,weight=1)
myWindow.configure(background='gray')


#***FRAMES buttons
# adjust r,c,sticky, row and column config as need
frame1=Frame(myWindow,width=130,height=300,bg='lightblue')
frame1.grid(row=0, column=0, sticky='NS', padx=10, pady=10, columnspan=1,rowspan=4)
frame1.rowconfigure(0,weight=1)
frame1.rowconfigure(1,weight=1)
frame1.rowconfigure(2,weight=1)
frame1.rowconfigure(3,weight=1)
frame1.columnconfigure(0,weight=1) #the lastcol goes along with rigth side expanding



#frame2  Right 
# adjust r,c,sticky, row and column config as need
frame2=Frame(myWindow,width=300,height=300,bg='blue')
frame2.grid(row=1, column=1, sticky='NESW', padx=(0,10), pady=(0,10), columnspan=1,rowspan=4) #padding ALSO takes two arguments tuple
frame2.rowconfigure(0,weight=1)
frame2.rowconfigure(1,weight=1)
frame2.rowconfigure(2,weight=1)
frame2.columnconfigure(1,weight=1) #the lastcol goes along with rigth side expanding

#Top frame
frame3=Frame(myWindow,width=100,height=100,bg='lightblue')
frame3.grid(row=0, column=1, sticky='NESW', padx=(0,10), pady=10, columnspan=2) #padding ALSO takes two arguments tuple
frame3.rowconfigure(1,weight=0)
frame3.columnconfigure(1,weight=1) #the lastcol goes along with rigth side expanding



#frame3 info
AppTitleLabel=Label(frame3, width=40,text="   Time Delay methods Display               ")
CompanyName=Label(frame3, text="YourCompanyName")
AppTitleLabel.grid(row=0, column=0, padx=0, pady=10, columnspan=2) #span 2 so it does not affect component button
CompanyName.grid(row=0, column=3, padx=10, sticky='E') #Keep


#place to put time
Time_Label1=Label(frame2,height=2,text="Put time Here",font=('Arial',20,''))
Time_Label1.grid(row=0, column=0, padx=10, pady=10, columnspan=2,sticky='WE') #span 2 so it does not affect component button
Label.config(Time_Label1,text="")



#place to put time
Time_Label3=Label(frame2,height=2,text="Put time Here",font=('Arial',20,''))
Time_Label3.grid(row=1, column=0, padx=10, pady=10, columnspan=2,sticky='WE') #span 2 so it does not affect component button
Label.config(Time_Label3,text="")

Time_Label4=Label(frame2,height=2,text="Put time Here",font=('Arial',20,''))
Time_Label4.grid(row=2, column=0, padx=10, pady=10, columnspan=2,sticky='WE') #span 2 so it does not affect component button
Label.config(Time_Label4,text="")

Label_List=[Time_Label3,Time_Label4]

def GetTime():
    TimeNow=time.time()
    delay_sec=2
    time.sleep(delay_sec) #this is blocking type function in tkinter main thread so remember avoid
    TimeAfter=time.time()
    #TimeNow_datetime=datetime.datetime.now()    
    #Label.config(Time_Label,text=TimeNow) # time from some long ago time ref still good for delta
    #Label.config(Time_Label,text="Date Time factional time: "+str(TimeNow_datetime))
    #Label.config(Time_Label,text="Time format: "+str(TimeNow_datetime.strftime("%H:%M:%S")))
    #Label.config(Time_Label,text="Date m/d/Y format: "+str(TimeNow_datetime.strftime("%m/%d/%Y")))#
    
    deltaTime=TimeAfter-TimeNow
    Label.config(Time_Label1,text=str(delay_sec)+"sec delay: "+str(deltaTime))

#thread starter
def GetTime_w_Thread():
    threading.Thread(target=GetTime, daemon=True).start() #important WITHOUT the () on the function otherwise it blocks
    print("threading notice same function that had time.sleep but not in tkinter thread,its own")

#Two Parts  The Thread and a non-Thread checker
#Testing non-Thread and Thread call to this functino
Done_Flag=[0,0] #two thread use
def GetTime2(StartingTime=None,Which_Label=0,delay_sec_arg=0.0):
    global Label_List
    global Done_Flag
    global Button_List
    print(Which_Label)
    #(Button_List[Which_Label])['state']='disabled' #I do see that a large time.sleep in thread 
    #can still affect button state from changing quickly even if time.sleep is after the button state
    #many have stated to not have tkinter type call in thread so need to work that
    myWindow.update
    delay_sec=delay_sec_arg
    TimeNow=time.time()
    time.sleep(0.001) #this is used to testout if function is "really" running "move GUI test" thread base , adjust to make thread slow or fast to see is_alive affect
    #the very first thread run is ok but since 'after' is calling not thread it blockable again (move the gui after press)
    deltaTime=TimeNow-StartingTime
    Label.config(Label_List[Which_Label],text=str(delay_sec)+"sec delay: " + str("{:0.3F}".format(deltaTime)))
    if(deltaTime>=delay_sec):
      Label.config(Label_List[Which_Label],text=str(delay_sec)+"sec delay: " + str("{:0.3F}".format(deltaTime))) #remember the : infront of format number
      Done_Flag[Which_Label]=1
      Button_List[Which_Label]['state']='normal'
    #Done do it here   if(Done_Flag[Which_Label]==0):myWindow.after(100,lambda:GetTime2(StartingTime,Which_Label,delay_sec)) #to low a after time WILL overload CPU time
    return

#non-thread checker
def Start_Checking_The_Thread(TD,StartingTime,Which_Label,delay_sec_arg):
    global Done_Flag
    print(TD.is_alive())
    if(TD.is_alive()): 
        print("Thread is still alive") #if the threaded function is slow you will see alive more offen
    else:
        print("Thread is done") # if the thread function is quick you will be done more offen
    if(Done_Flag[Which_Label]==0):
        #NO this was not really running a thread TD=threading.Thread(target=GetTime2(StartingTime,Which_Label,delay_sec_arg), daemon=True)
        TD=threading.Thread(target=GetTime2,args=(StartingTime,Which_Label,delay_sec_arg,), daemon=True) #important no () on target function
        TD.start()
        TD.is_alive()
        # if you make after to small it will comsume CPU percent - just know this d- alway how slow can i go still be ok with app (100ms can give +/-100ms error to time)
        myWindow.after(50,lambda:Start_Checking_The_Thread(TD,StartingTime,Which_Label,delay_sec_arg)) #to0 low an after time WILL overload CPU time
        #too low a ms after time WILL overload CPU time and tkinter thread , need to find a balance that works for your app
        #with 50ms: accuracy +codetime0+/-50ms not absolute since on Windows you are not the only app(aka NOT Realtime computer)
        #check with the task manager(windows) to see if cpu using to to high if it is you need to increase the after time
    else:        
        print("done checking") #to0 low an after time WILL overload CPU time
    return

#thread starter button event
def GetTime_w_Thread2(Which_Label=0,delay_sec_arg=0.0):
    global Label_List
    global Button_List
    global Done_Flag
    Done_Flag[Which_Label]=0
    global StartingTime
    (Button_List[Which_Label])['state']='disabled'
    StartingTime=time.time()
    print(StartingTime)
    #in "this" particle case both non-thread and thread working "Simalarly" but not the same (non-Thread can be blocked)
    #GetTime2(StartingTime,Which_Label,delay_sec_arg) #this works but NOT Threading
    TD=threading.Thread(target=GetTime2(StartingTime,Which_Label,delay_sec_arg), daemon=True)
    TD=threading.Thread(target=GetTime2,args=(StartingTime,Which_Label,delay_sec_arg,), daemon=True)

    TD.start()
    print("Thread",TD.is_alive())
    #threading.Thread(target=GetTime2,args=(StartingTime,Which_Label,delay_sec_arg), daemon=True).start()
    Start_Checking_The_Thread(TD,StartingTime,Which_Label,delay_sec_arg)
    print("Thread",TD.is_alive())

b_width=20
GetTime_Btn=Button(frame1, text='GetDelta with \n time.sleep delay 2sec \n freeze tk GUI for \n that time',\
                   width=b_width, command=lambda:GetTime())
GetTime_Btn.grid(row=0, column=0,padx=10,pady=10) 

GetTime_Btn=Button(frame1, text='GetDelta with \n time.sleep delay 2sec\n and thread \n does NOT freeze tk GUI for \n that time',\
                   width=b_width, command=lambda:GetTime_w_Thread())
GetTime_Btn.grid(row=1, column=0,padx=10,pady=10)

StartTime=time.time()
GetTime2_Btn=Button(frame1, text='GetDelta with 2s\n "after" \n and thread',width=b_width, command=lambda:GetTime_w_Thread2(0,2.0))
GetTime2_Btn.grid(row=2, column=0,padx=10,pady=10)

GetTime3_Btn=Button(frame1, text='GetDelta2 with 3s \n "after \n and thread',width=b_width, command=lambda:GetTime_w_Thread2(1,3.0))
GetTime3_Btn.grid(row=3, column=0,padx=10,pady=10)

Button_List=[GetTime2_Btn,GetTime3_Btn]
   
#main Window  GUI looping
myWindow.mainloop()

Python code download

Python-tkinter and time Download

Notes

Presentation: Python Learn Tkinter and time delay examples
Programming Language used: Python 3.7 in Spyder
Presentation app: Microsoft’s PowerPoint
Python and Tkinter are products of respective company
Lots of Help and credit to “Stackoverflow” ,product of respective company
Presentation shown to spark ideas of use.
This presentation is not connected to or endorsed by any company.
Use at your own risk.
Tags: Python, Python3.7, Tkinter, GUI, List, Thread ,Tkinter and Timedelay, TimeDelay, After function, Python Learn Tkinter and time delay examples

Posted in Test Sector | Tagged after method, frame, GUI, Python, Python tkinter and time delay, Python3.7, Threading, time delay, tkinter | Leave a comment

Python – MCC USB-1208FS-Plus

Posted on April 13, 2023 by LV_TS_Test_Engineer_3000_VI

Using Python to see connection and simple measurement using MCC’s USB-1208FS-Plus

Presentation

Python code text see in console result

# -*- coding: utf-8 -*-
"""
Created on Thu Apr 13 08:52:18 2023

@author: aleja
"""

from mcculw import ul
from mcculw.enums import ULRange
from mcculw.ul import ULError
import time


board_num=0
channel=0
ai_range=ULRange.BIP10VOLTS
try:
   for i in range (10): 
    my_value=ul.a_in(board_num,channel,ai_range)
    eng_units_value=ul.to_eng_units(board_num,ai_range,my_value)
#    print("Raw Value;"+str(my_value))
    print("Eng Value:"+'{:0.3f}'.format(eng_units_value))
    time.sleep(0.1)
except ULError as e:
    print("A message from UL code:" +str(e.errorcode)+"msg:" + str(e.message))

Down of simple measurement to see on console

Python and MCC DAQ 1208FS-Plus Download

Notes

Presentation: Python and MCC DAQ 1208FS-Plus
MCC, Measurement Computing Corp is own by NI (previously know as National Instruments)
Programming Language used: Python 3.7 in Spyder
Presentation app: Microsoft’s PowerPoint
Python of respective company
Presentation shown to spark ideas of use.
This presentation is not connected to or endorsed by any company.
Use at your own risk.
Tags: MCC DAQ USB-1208FS-Plus, MCC,Python, MCCULW for python,PIP
Future possibilities: Making a Python Tkinter to show readings
DaqDevDiscovery01 example form MCC github code (see presentation)

Posted in MCC_USB_1208FS_Plus, Python, Test Sector | Tagged MCC DAQDiscovery example, Measurement Computing Corp, Python, Python3.7, USB-1208FS-Plus | Leave a comment

Python – Learn Queue GUI

Posted on April 12, 2023 by LV_TS_Test_Engineer_3000_VI

Tkinter GUI to learn Queue, Put, Get, Empty, Full, Exception Handling

Short video about 42sec

Python Learn Queue – Code Text

# -*- coding: utf-8 -*-
# 
#Date: 4/11/2023 Time 3:24 PM
#

from tkinter import *
from queue import Queue,Full,Empty
import threading as td

def Test_Q_Empty(q):
      if(q.empty()):
          canv1.itemconfigure(Queue_Empty_LED,fill='lightgreen')
      else:
          canv1.itemconfigure(Queue_Empty_LED,fill='grey')
      return

def Test_Q_Full(q):
      if(q.full()):
          canv2.itemconfigure(Queue_Full_LED,fill='lightgreen')
      else:
          canv2.itemconfigure(Queue_Full_LED,fill='grey')
      return        
          
def Refresh_Label_autoscroll():
    global Label_Result_List
    RESULT['text']=""
    for line in Label_Result_List:
       RESULT['text']=RESULT['text'] + str(line)+"\n"
    myWindow.update()   
    return   

Test_Result_List=[]
#Test_Result_Dict={'TestName':"",'Measured':0,'Result':"NotTested"} Dont DO THIS or all will be the same

Num_of_Test=20
TRD={}
for i in range(Num_of_Test):
    Test_Result_Dict={} #this way
    Test_Result_Dict['TestName']="TestName_"+"{:02d}".format(i)  #formating 2 digits
    Test_Result_Dict['Measured']=i+100
    Test_Result_Dict['Result']="Passed"
    Test_Result_List.append(Test_Result_Dict)
    print(Test_Result_Dict)    

#Google promtp: print a list with carriage return in one line
#my find credit: stackoverflow "Printing list element on spearate lines in Python": (3rd Answer)
print(*Test_Result_List,sep="\n")
Label_Result_List=[]
#beginner error -- wrong way touching one will affect the other (like pointer) Label_Result_List=Test_Result_List
Label_Result_List=Test_Result_List.copy() #use copy to make a Different list

#print(Test_Result_List)

#GUI setup below
myWindow=Tk()
myWindow.title("Python-Learn_Queue_GUI")
myWindow.minsize(810,460)


# do this or frame in window will not follow window (expanding)
myWindow.grid_rowconfigure(0,weight=1)  #need on row define as 1 for expanding row wise bottomframe
myWindow.grid_columnconfigure(0,weight=1)
#only one frame so 0,0 configure

#frame1 
# adjust r,c,sticky, row and column config as need
frame1=Frame(myWindow,width=50,height=50,bg='lightblue')
frame1.grid(row=0, column=0, sticky='NWES', padx=10, pady=10, columnspan=1)
frame1.rowconfigure(8,weight=1) #only expand after last button
frame1.columnconfigure(5,weight=1) #the lastcol goes along with rigth side expanding
#where do you want it to exapand column5  last row 

#LED info
LTRY=5 #light top right Y
LTRX=15 #light top right X
dia=20


#Label used canv text instead so its close to led
#Q_EMPTY=Label(frame1, text="Q is Empty",width=15)
#Q_EMPTY.grid(row=3, column=2, padx=10, pady=(10,0), columnspan=1,sticky='N')



#Led Indictor
canv1=Canvas(frame1,width=150, height=30, bg='lightblue', bd=1, highlightthickness=1)
canv1.grid(row=4, column=2, columnspan=1,sticky="")
Queue_Empty_LED=canv1.create_oval(LTRX,LTRY,LTRX+dia,LTRY+dia,fill='black')
Queue_Empty_Text=canv1.create_text(80,LTRX,width=100,text="Q is Empty")

#Label
#Q_FULL=Label(frame1, text="Q is Full",width=15)
#Q_FULL.grid(row=5, column=2, padx=10, pady=(10,0), columnspan=1,sticky='N')

#Led Indictor

canv2=Canvas(frame1,width=150, height=30, bg='lightblue', bd=1, highlightthickness=1)
canv2.grid(row=5, column=2, columnspan=1,sticky="")
Queue_Full_LED=canv2.create_oval(LTRX,LTRY,LTRX+dia,LTRY+dia,fill='black')
Queue_Full_Text=canv2.create_text(80,LTRX,width=100,text="Q is full")

canv3=Canvas(frame1,width=150, height=30, bg='lightblue', bd=1, highlightthickness=1)
canv3.grid(row=6, column=2, columnspan=1,sticky="")
Queue_Msg_LED=canv3.create_oval(LTRX,LTRY,LTRX+dia,LTRY+dia,fill='black')
Queue_Mag_Text=canv3.create_text(80,LTRX,width=100,text="Q Exception Handled ")
#achor and justify tricky in create text it work better without them in this case


#Label
APP_NAME=Label(frame1, text=" Testing - Queue Functions ",width=25)
APP_NAME.grid(row=0, column=0, padx=10, pady=10, columnspan=1,sticky='')

#Label
COMPANY_NAME=Label(frame1, text="testengineerresource.com",width=25)
COMPANY_NAME.grid(row=0, column=5, padx=10, pady=10, columnspan=1,sticky='E')

#Label
USERMSG=Label(frame1, text="Message Area",width=25)
USERMSG.grid(row=2, column=5, padx=10, pady=10, columnspan=1,sticky='E')

#Label
RESULT=Label(frame1, text="NoInfoYet",width=25,height=20,anchor='nw',justify='left')
RESULT.grid(row=3, column=5, padx=10, pady=10, columnspan=1,rowspan=7,sticky='NWSE')
#rowspan all rows so button not affected
#only Result Label will expand with window all directions



#Button
Q_PUT=Button(frame1, text='Q_PUT',width=15, command=lambda:frame_Button_Q_PUT("Q_PUT"))
Q_PUT.grid(row=3, column=0,padx=10,pady=10,sticky='')

Test_Index=0

def frame_Button_Q_PUT(button_text):
    global Done_Flag
    global Test_Index
    print(button_text)
    Test_Q_Full(que)
    Test_Q_Empty(que)
    if(Test_Index<Num_of_Test):
        try:    
            print("Test Index: ",Test_Index)
            print(Test_Result_List[Test_Index])
            if(que.empty()):
                Done_Flag=False
                td.Thread(target=Tell_Manager_Done(que), daemon=True).start()
            que.put(Test_Result_List[Test_Index],block=False)  #not que.put= NO, added timeout so you can see affect but will not hang app
            #que.put(Test_Result_List[Test_Index],timeout=1)  #not que.put= NO, added timeout so you can see affect but will not hang app
            Label_Result_List.append("Queue Add:"+str(Test_Result_List[Test_Index]))
            Label_Result_List.pop(0)
            Refresh_Label_autoscroll()  #a way to gave a scrollable label could not find a good label end to autoscroll, almost a que by list, really should have been text with scrollbar
            canv3.itemconfigure(Queue_Msg_LED,fill='gray')
            Test_Index=Test_Index+1
        except Full:
            canv3.itemconfigure(Queue_Msg_LED,fill='red')
            Label_Result_List.pop(0)
            Label_Result_List.append("Queue is Full and attempted Put performed, Suggest Q_Get") 
            Refresh_Label_autoscroll()  #  
            print("Handling Que Error Put on a Filled up que")
            pass  #continue
    else:
        Label_Result_List.pop(0)
        Label_Result_List.append("No more Test in List")        
        Refresh_Label_autoscroll()
        Reload_TestList['state']='normal'
    Test_Q_Full(que)
    Test_Q_Empty(que)
    print(button_text)
    return





#Button  ======Q_GET
Q_GET=Button(frame1, text='Q_GET',width=15, command=lambda:frame_Button_Q_GET("Q_GET"))
Q_GET.grid(row=4, column=0,padx=10,pady=10,sticky='')

def frame_Button_Q_GET(button_text):
  global Done_Flag  
  print(button_text)
  Test_Q_Empty(que)
  Test_Q_Full(que)  
  try:
    item=que.get(block=False) #equivalent .get_nowait #see how block= false behaves, t1sec this can halt here if no que most time not desired 
    #item=(que.get(timeout=1)) #t1sec this  can halt here if no que most time not desired 

    Label_Result_List.pop(0)
    Label_Result_List.append("Queue Get:"+str(item))
    Refresh_Label_autoscroll()  #a way to gave a scrollable label could not find a good label end to autoscroll, almost a que by list, really should have been text with scrollbar    
    canv3.itemconfigure(Queue_Msg_LED,fill='gray')
  except Empty: #credit stackoverflow:"Python Queue.Empty Exception handling" the last answer in list help me
      canv3.itemconfigure(Queue_Msg_LED,fill='red')
      print("Handling Que Error Get on an empty que")
      Label_Result_List.pop(0)
      Label_Result_List.append("Queue is Empty and attempted Get performed, Suggest Q_PUT") 
      Refresh_Label_autoscroll()  #  
      #####que.task_done() # can not use in tkinter GUI
      Done_Flag=True
      pass  #continue
  Test_Q_Empty(que)
  Test_Q_Full(que)
  return



#Button
Q_DATA=Button(frame1, text='Q_DATA',width=15, command=lambda:frame_Button_Q_DATA("Q_DATA"))
Q_DATA.grid(row=7, column=0,padx=10,pady=10,sticky='')

def frame_Button_Q_DATA(button_text):
  print(button_text)
  Label_Result_List.pop(0)
  Label_Result_List.append("How many item in q: "+str(que.qsize())) 
  Refresh_Label_autoscroll()  # 
  for item in list(que.queue):
      print("Item in Que",item)
      Label_Result_List.pop(0)
      Label_Result_List.append("Item in que: "+str(item)) 
      Refresh_Label_autoscroll()  # 
  return

#Button
Reload_TestList=Button(frame1, text='Reload_TestList',width=15, command=lambda:frame_Button_Reload_TestList("Reload Test List"))
Reload_TestList.grid(row=8, column=0,padx=10,pady=10,sticky='')

def frame_Button_Reload_TestList(button_text):
  print(button_text)
  global Test_Index
  Test_Index=0
  Reload_TestList['state']='disabled'
  return

def Wait_Here():
    global Done_Flag
    print("Thread:Manager wait for you to finish gets", Done_Flag)
    if Done_Flag:
        Label_Result_List.pop(0)
        Label_Result_List.append("Manager I finished reviewing my current que items, more work please") 
        Refresh_Label_autoscroll()
        print("Told Manager I finished my current review of tests")
        Done_Flag=False
    else:
        myWindow.after(1000,Wait_Here)  
        

def Tell_Manager_Done(que):
    global Done_Flag
    print("Started thread")
    #que.join() # YOU know you can not use this in a tkinter GUI
    Done_Flag=False
    Wait_Here()
    #myWindow.update()
    print("finshied a thread")
    return



que=Queue(10)  #max size to to start learning
USERMSG['text']="Max Size of Q=: "+str(que.maxsize)


#show starting list for put to use
RESULT['text']=""
for line in Label_Result_List:
  RESULT['text']=RESULT['text'] + str(line)+"\n"
Reload_TestList['state']='disable'
Done_Flag=True #since at start empty que

#GUI main loop  
myWindow.mainloop()

Download of code

Python_Learn_Queue_v2 Download

Notes

Presentation: Python Learn Queue GUI using
Programming Language used: Python 3.7 in Spyder
Presentation app: Microsoft’s PowerPoint
Python and Tkinter are products of respective company
Lots of Help and credit to “Stackoverflow” product of respective company
Presentation shown to spark ideas of use.
This presentation is not connected to or endorsed by any company.
Use at your own risk.
Tags: Python, Python3.7, Tkinter, Queue, Canvas ,GUI, List, Dictionary, and Thread (limited scope)

Posted in Python, Queue, Test Sector, tkinter | Tagged Canvas, Create oval, Create Text, GUI, LED on Canvas, Python, Python Learn Queue, Python3.7, Threading, tkinter | Leave a comment

Python – Analog Meter GUI example

Posted on April 9, 2023 by LV_TS_Test_Engineer_3000_VI

Show use of Python tkinter canvas to create meter and also vertical slider (scale) with binding

Short video of Analog Meter GUI example

Text of Python code

# -*- coding: utf-8 -*-
"""
Created on Sat Apr  8 15:04:12 2023

@author: aleja

Analog Meter GUI and Demo for learning

"""

from tkinter import *
#for some reason from tkinter.ttk import * cause bg lightblue error
from tkinter.ttk import Combobox
import math
import time
#import os    #for path filename join
#import threading


#GUI setup below
myWindow=Tk()
myWindow.title("myWindow-Analog Meter GUI")
w_w=820
w_h=400
myWindow.minsize(w_w,w_h)
myWindow.maxsize(w_w,w_h) #if you want to move the operator table to see rest of belt comment out
#next time use resize=false,false

# do this or frame (last frame row number, in window will not follow window (expanding)
myWindow.grid_rowconfigure(0,weight=1)  #Important This was the reason for  on frame being stuck at bottom was row 0 but 3frames
myWindow.grid_columnconfigure(1,weight=1)
myWindow.configure(background='gray')

MaxDeg=180  #keep dont change for demo, it important for 180 deg display meter
MinDeg=0    #Keep dont change for demo
EngMax=10
EngMin=0
MeterValue=0


def EngNum_to_Deg(EngNum):
    M_slope=((MaxDeg-MinDeg)/(EngMax-EngMin))
    Deg=M_slope*(EngNum-EngMin)
    return Deg

def Deg_to_EngNum(Deg0_180):
    M_slope=((EngMax-EngMin)/(MaxDeg-MinDeg))
    EngNum=M_slope*(Deg0_180)+EngMin
    return EngNum

def Update_Meter(event=None,EventMsg="NoMsg"): # I am a relative novice for this event obj arg , its in my learning curve,it did not hiddern this demo
    """ 
    Description: Update the Meters red pointer \n
    Arguments: arg event is tkinter obj when bind events, EventMsg is user string\n
    Other: currently Dont know how to use event object directly yet, so using EventMsg in this demo
    \nOther: using default None so i can use this function without event also.
    """
    global MeterValue

    if event==None:
        #just a note to remind when a function call was made that as event=None
        str_note="reminder,Please note event arg was  empty so dont used it"
        #print(str_note)
    #Update the pointer on the meter
    #MeterValue=(MeasNum.get())
    MeterValue=MeasNum.get()  
    #VSlider.set(MeterValue)
    Deg=(EngNum_to_Deg(MeterValue))-90
    RadDeg=math.radians(Deg)
    line_length=115
    line_x=line_length * math.sin(RadDeg)
    line_y=line_length * math.cos(RadDeg)
    canv2.coords(MeterPointer,Center_Dot_x,Center_Dot_y,Center_Dot_x+line_x,Center_Dot_y-line_y)
    #canv2.create_line(Center_Dot_x,Center_Dot_y,Center_Dot_x+line_x,Center_Dot_y-line_y,fill='red',width=3,arrow='last')# remember y going up is less
    canv3.itemconfigure(Reading_Value,text=str(MeterValue),anchor='w')
    canv3.itemconfigure(Event_Label_Info,text=str(EventMsg),anchor='w')
    myWindow.update()
    

#***FRAMES
# adjust r,c,sticky, row and column config as need
frame1=Frame(myWindow,width=120,height=300,bg='lightblue')
frame1.grid(row=0, column=0, sticky='NSWE', padx=10, pady=10, columnspan=1,rowspan=2)
frame1.rowconfigure(0,weight=1)
frame1.columnconfigure(0,weight=0) #the lastcol goes along with rigth side expanding



#frame2  Right 
# adjust r,c,sticky, row and column config as need
frame2=Frame(myWindow,width=300,height=300,bg='blue')
frame2.grid(row=1, column=1, sticky='NESW', padx=(0,10), pady=(0,10), columnspan=1) #padding ALSO takes two arguments tuple
frame2.rowconfigure(0,weight=1)
frame2.columnconfigure(1,weight=1) #the lastcol goes along with rigth side expanding

#Top frame
frame3=Frame(myWindow,width=100,height=100,bg='lightblue')
frame3.grid(row=0, column=1, sticky='NESW', padx=(0,10), pady=10, columnspan=1) #padding ALSO takes two arguments tuple
frame3.rowconfigure(1,weight=0)
frame3.columnconfigure(1,weight=1) #the lastcol goes along with rigth side expanding

#frame3 info
AppTitleLabel=Label(frame3, text="   Analog Meter Display               ")
CompanyName=Label(frame3, text="YourCompanyName")
AppTitleLabel.grid(row=0, column=0, padx=0, pady=10, columnspan=2) #span 2 so it does not affect component button
CompanyName.grid(row=0, column=3, padx=10, sticky='E') #Keep

# ===============Meter_Info =================
Meter_Width=300
Meter_Height=300


#Meter Povit Point Center Dot
Dot_Padding=10
Center_Dot_x=Meter_Width/2+Dot_Padding
Center_Dot_y=Meter_Height/2+Dot_Padding
Center_Dot_radius=10

canv2=Canvas(frame2,width=Meter_Width+30, height=Meter_Height, bg='lightblue', bd=0, highlightthickness=0)
canv2.grid(row=0, column=0, columnspan=1,padx=20,pady=10)
canv2.create_oval(Center_Dot_x-Center_Dot_radius,Center_Dot_y-Center_Dot_radius,\
                  Center_Dot_x+Center_Dot_radius,Center_Dot_y+Center_Dot_radius,fill='blue')

#===  Two Arc for Major and Minor tick marks
arcx=Center_Dot_x
arcy=Center_Dot_y
arc_circle_radius=100
coord_arc=(arcx-arc_circle_radius,arcx-arc_circle_radius,\
           arcx+arc_circle_radius,arcx+arc_circle_radius)
arc_startDeg=0
arc_endDeg=180
canv2.create_arc(coord_arc,start=arc_startDeg,extent=arc_endDeg)

arc_circle_radius=120
coord_arc=(arcx-arc_circle_radius,arcx-arc_circle_radius,\
           arcx+arc_circle_radius,arcx+arc_circle_radius)
canv2.create_arc(coord_arc,start=arc_startDeg,extent=arc_endDeg)

#=== create first starting Meter Pointer red arrow line
MeterValue=0  #unscale 0-180
Deg=MeterValue-90
RadDeg=math.radians(Deg)
line_length=115
line_x=line_length * math.sin(RadDeg)
line_y=line_length * math.cos(RadDeg)

 
MeterPointer=canv2.create_line(Center_Dot_x,Center_Dot_y,Center_Dot_x+line_x,Center_Dot_y-line_y,fill='red',width=3,arrow='last')# remember y going up is less


scale_Top=180
scale_Bottom=0


#binding keys and mouse
#=== Veritical Slider used to change Meter Pointer (reading) ===============================
MeasNum=DoubleVar()  
VSlider=Scale(frame1,from_=EngMax, to=EngMin,length=150,variable=MeasNum,digits=3,resolution=0.1)
VSlider.grid(row=0,column=0) #dont forget the odd underscore on from
#Becasue the slider would generate tons of event using release and I DONT KNOW how have ,not found ScaleChanged event
VSlider.bind('<ButtonRelease-1>',lambda event: Update_Meter(event,"Mouse Released"))
#important <Up> is not equal to <KeyRelease-Up>  Up only was causing a missing event that cause a one resolution offset
VSlider.bind('<KeyRelease-Up>',lambda event: Update_Meter(event,"Up key Pressed"))  #just using UP will give on missing event which cause odd 0.1 offest
VSlider.bind('<KeyRelease-Down>',lambda event: Update_Meter(event,"Down key Pressed"))
#Not working this way VSlider.bind('<ButtonRelease-1>,<Up>,<Down>',Update_Meter)
VSlider.focus_set() #focus is important
frame1.focus_force() #focus is important for demo so the frame will listen to the up and down keys both the keypad, and keyboard area
#interesting ctrl and up key moved it in big steps, not the shift key the ctrl key

#======= Majore and Minor ====== Tick markers
#major line
for iDeg in range(-90,91,10):   #because of axis  0-180  = -90 to 90
    RadDeg=math.radians(iDeg)
    subline_length=100
    subline_x1=subline_length * math.sin(RadDeg)
    subline_y1=subline_length * math.cos(RadDeg)
    subline_length=120
    subline_x2=subline_length * math.sin(RadDeg)
    subline_y2=subline_length * math.cos(RadDeg)
    canv2.create_line(Center_Dot_x+subline_x1,Center_Dot_y-subline_y1,\
                      Center_Dot_x+subline_x2,Center_Dot_y-subline_y2,fill='black',width=3)# remember y going up is less
#minor line
for iDeg in range(-90,91,2):
    RadDeg=math.radians(iDeg)
    subline_length=100
    subline_x1=subline_length * math.sin(RadDeg)
    subline_y1=subline_length * math.cos(RadDeg)
    subline_length=120
    subline_x2=subline_length * math.sin(RadDeg)
    subline_y2=subline_length * math.cos(RadDeg)
    canv2.create_line(Center_Dot_x+subline_x1,Center_Dot_y-subline_y1,\
                      Center_Dot_x+subline_x2,Center_Dot_y-subline_y2,fill='gray',width=1)# remember y going up is less
    

Meter_Text_Canv_List=[]
def Update_Meter_MajorText():
    global Meter_Text_Canv_List
    """
    Updates the Meters Major Text Number
    """
    #Number text on Major ticks
    MeterNumMajor=0
    
    for iDeg in range(-90,91,10):
        MeterNumMajor=Deg_to_EngNum(iDeg+90)
        RadDeg=math.radians(iDeg)
        Text_Radius_Loc=140
        Text_x1=Text_Radius_Loc * math.sin(RadDeg)
        Text_y1=Text_Radius_Loc * math.cos(RadDeg)
        M_T_C=canv2.create_text(Center_Dot_x+Text_x1,Center_Dot_y-Text_y1,fill="black",text=round(MeterNumMajor,1),font=('Arial',9,''))
        Meter_Text_Canv_List.append(M_T_C)
        MeterNumMajor=MeterNumMajor+10

Update_Meter_MajorText()

#=== Canvas 3
# canv3 side info on Right
canv3=Canvas(frame2,width=Meter_Width, height=Meter_Height, bg='black', bd=0, highlightthickness=0)
canv3.grid(row=0, column=1, columnspan=1,padx=20,pady=10)

#some info on right side convas - Reading will get a value when updating vertical slider(called scale in python)
Info_Label=canv3.create_text(10,0,fill="white",text="Use the mouse in demo \n to move the slider or \n the Up, Down keys",anchor='nw',font=('Arial',14,''))
Reading_Value=canv3.create_text(50,100,fill="white",text="",font=('Arial',20,''),anchor="center")
Event_Label_Info=canv3.create_text(10,150,fill="white",text="",font=('Arial',14,''))

def Zero_Slider():
    VSlider.focus_force
    if (EngMin<0):
        MeasNum.set(0)
    else:    
        MeasNum.set(EngMin)
    Update_Meter(None,"Min/Zero Button released") #warning not using event arg or in function
    return


def Meter_and_Slider_Update(Emin=0,Emax=10):
    global Meter_Text_Canv_List
    global EngMax
    global EngMin
    EngMax=Emax
    EngMin=Emin
    #first delete current text
    for M_T_C_item in Meter_Text_Canv_List:
        canv2.delete(M_T_C_item)
    Update_Meter_MajorText()
    VSlider.configure(from_=EngMax,to=EngMin)
    VSlider.focus_force
    if(EngMin<0):
       VSlider.set(0)
       MeasNum.set(0)
    else:
       VSlider.set(EngMin)
       MeasNum.set(EngMin) 
    Update_Meter(None,"Min Button released") #warning not using event arg or in function
    return

def PrintConsole():
    print(MeterValue,MeasNum.get(),VSlider.get())
    VSlider.set(MeterValue)

Zero_VSlider_Btn=Button(frame1, text='Min',width=15, command=lambda:Zero_Slider())
Zero_VSlider_Btn.grid(row=1, column=0,padx=19,pady=2)  

Zero_to_10_Btn=Button(frame1, text='Eng(0-10)',width=15, command=lambda:Meter_and_Slider_Update(0,10))
Zero_to_10_Btn.grid(row=2, column=0,padx=10,pady=2) 

Zero_to_5_Btn=Button(frame1, text='Eng(0-5)',width=15, command=lambda:Meter_and_Slider_Update(0,5))
Zero_to_5_Btn.grid(row=3, column=0,padx=10,pady=2) 

Four_to_20_Btn=Button(frame1, text='Eng(4-20)',width=15, command=lambda:Meter_and_Slider_Update(4,20))
Four_to_20_Btn.grid(row=4, column=0,padx=10,pady=2)

N10_to_P10_Btn=Button(frame1, text='Eng(N10-P10)',width=15, command=lambda:Meter_and_Slider_Update(-10,10))
N10_to_P10_Btn.grid(row=5, column=0,padx=10,pady=2)  

PrintConsole_Btn=Button(frame1, text='PrintConsole',width=15, command=lambda:PrintConsole())
PrintConsole_Btn.grid(row=6, column=0,padx=10,pady=2)  


#main Window  GUI looping
myWindow.mainloop()

Download for code

Python-Analog Meter Display_v3 Download

Notes

Presentation: Analog Meter Display GUI using Vertical slider for input to meter, show different scale changes
Programming Language used: Python 3.7 in Spyder
Presentation app: Microsoft’s PowerPoint
Python and Tkinter are products of respective company
Presentation shown to spark ideas of use.
This presentation is not connected to or endorsed by any company.
Use at your own risk.
Tags: Python, Python3.7, Tkinter , Canvas ,GUI, List, Dictionary, StringVar,Calling, Event binding , Default None for Event, Key and Mosue binding, KeyRelease-Up, KeyRelease-Down

Posted in Test Sector | Tagged Analog Meter, Analog Meter GUI Example, Canvas, Event binding, KeyRelease-Down, KeyRelease-Up, Python, Python3.7, tkinter, Veritcal slide, Vertical scale | Leave a comment

Python- Updated Wafer Display GUI with Test types

Posted on April 7, 2023 by LV_TS_Test_Engineer_3000_VI

Updated a previous Wafer Display GUI

Able to show what type failure occurred for different test by changing color of die. Also a Stop Testing button

Video of combobox test type to show failed die, also show other die in overall failure so user does not think it has less total failures

showing the different Test type failure

Code Text

# -*- coding: utf-8 -*-
"""
Created on Mon Apr  3 10:21:48 2023

@author: aleja
"""

from tkinter import *
#for some reason from tkinter.ttk import * cause bg lightblue error
from tkinter.ttk import Combobox
#import math
import time
#import os    #for path filename join
#import threading

Stop_Flag=0
sim_OE_Failure_List=[(8,16)]
sim_Tx_Failure_List=[(9,16),(16,8)]
sim_Rx_Failure_List=[(9,16),(16,8),(16,9)]

#row col added to allow for simulated failure at specific r,c die for demo
def OE(row,col):
    print("Optical Test",row,col)
    #do Optical Electrical Test
    if (row,col) in sim_OE_Failure_List:
        result="Fail"
        if (row,col) not in sim_Die_FailedList:
          sim_Die_FailedList.append((row,col)) # add to Die_FailedList if not already inside        
    else:    
        result="Pass"
    return result

def Tx(row,col):
    #do Transmit Test
    print("Transmit test")
    if (row,col) in sim_Tx_Failure_List:
        result="Fail"
        if (row,col) not in sim_Die_FailedList:
          sim_Die_FailedList.append((row,col)) # add to Die_FailedList if not already inside  
    else:    
        result="Pass"
    return result

def Rx(row,col):
    #do Receiver Test
    print("Receiver Test")
    if (row,col) in sim_Rx_Failure_List:
        result="Fail"
        if (row,col) not in sim_Die_FailedList:
          sim_Die_FailedList.append((row,col)) # add to Die_FailedList if not already inside  
    else:    
        result="Pass"
    return result
    
#must be below function definition
Tests_seq=[OE,Tx,Rx]   #no string becasuse this will be functionName
Test_Result=["Pass","Fail","Error"] #not used


#GUI setup below
myWindow=Tk()
myWindow.title("myWindow-Wafer GUI example")
myWindow.minsize(900,400)
myWindow.maxsize(900,400) #if you want to move the operator table to see rest of belt comment out


# do this or frame (last frame row number, in window will not follow window (expanding)
myWindow.grid_rowconfigure(0,weight=1)  #Important This was the reason for  on frame being stuck at bottom was row 0 but 3frames
myWindow.grid_columnconfigure(1,weight=1)
myWindow.configure(background='gray')

#two Frames
#left and right
#frame1 Left
# adjust r,c,sticky, row and column config as need
frame1=Frame(myWindow,width=120,height=300,bg='lightblue')
frame1.grid(row=0, column=0, sticky='NSWE', padx=10, pady=10, columnspan=1,rowspan=2)
frame1.rowconfigure(0,weight=1)
frame1.columnconfigure(0,weight=0) #the lastcol goes along with rigth side expanding


#frame2  Right 
# adjust r,c,sticky, row and column config as need
frame2=Frame(myWindow,width=300,height=300,bg='blue')
frame2.grid(row=1, column=1, sticky='NESW', padx=(0,10), pady=(0,10), columnspan=1) #padding ALSO takes two arguments tuple
frame2.rowconfigure(0,weight=1)
frame2.columnconfigure(1,weight=1) #the lastcol goes along with rigth side expanding


Die_Column=20
Die_Row=20
#Dies
Die_w=15 #light top right Y
Die_h=15
Die_x=0
Die_y=0
Die_xpad=2
Die_ypad=2

#Led Indictor
Wafer_Width=Die_Column*Die_w+Die_xpad
Wafer_Height=Die_Row*Die_h+Die_ypad
canv2=Canvas(frame2,width=Wafer_Width, height=Wafer_Height, bg='lightblue', bd=0, highlightthickness=0)
canv2.grid(row=0, column=0, columnspan=1,padx=20,pady=10)


canv3=Canvas(frame2,width=Wafer_Width+30, height=Wafer_Height, bg='black', bd=0, highlightthickness=0)
canv3.grid(row=0, column=1, columnspan=1,padx=20,pady=10)

fbinx1=100
fbiny1=50
Result_pady=20


Pass_Bin_Label=canv3.create_text(fbinx1,fbiny1+20,fill="white",text="Pass",font=('Arial',20,''))
Pass_Bin_count=canv3.create_text(fbinx1+100,fbiny1+20,fill="white",text="0",font=('Arial',20,''))

Fail_Bin_Label=canv3.create_text(fbinx1,fbiny1+60,fill="white",text="Fail",font=('Arial',20,''))
Fail_Bin_count=canv3.create_text(fbinx1+100,fbiny1+60,fill="white",text="0",font=('Arial',20,''))

Total_Bin_Label=canv3.create_text(fbinx1,fbiny1+100,fill="white",text="Total",font=('Arial',20,''))
Total_Bin_count=canv3.create_text(fbinx1+100,fbiny1+100,fill="white",text="0",font=('Arial',20,''))

Die_Label=canv3.create_text(fbinx1,fbiny1+140,fill="white",justify="left",text="Die:",font=('Arial',14,''))
Die_RC_Label=canv3.create_text(fbinx1+100,fbiny1+140,fill="white",justify="left",text=" ",font=('Arial',14,''))

Test_Label=canv3.create_text(fbinx1,fbiny1+170,fill="white",justify="left",text="TEST:",font=('Arial',14,''))
Test_Name_Label=canv3.create_text(fbinx1+100,fbiny1+170,fill="white",anchor='center',justify="left",text=" ",font=('Arial',14,''))



frame3=Frame(myWindow,width=100,height=100,bg='lightblue')
frame3.grid(row=0, column=1, sticky='NESW', padx=(0,10), pady=10, columnspan=1) #padding ALSO takes two arguments tuple
frame3.rowconfigure(1,weight=0)
frame3.columnconfigure(1,weight=1) #the lastcol goes along with rigth side expanding


AppTitleLabel=Label(frame3, text="            Wafer GUI Display               ")
CompanyName=Label(frame3, text="YourCompanyName")
AppTitleLabel.grid(row=0, column=0, padx=0, pady=10, columnspan=2) #span 2 so it does not affect component button
CompanyName.grid(row=0, column=3, padx=10, sticky='E') #Keep


Die_Info_List=[]
Die_Canv_List=[]
Die_Not_Testable=[(0,0),(0,1),(0,2),(0,3),(0,4),(0,5),(0,6),(0,7),(0,8),\
                  (0,11),(0,12),(0,13),(0,14),(0,15),(0,16),(0,17),(0,18),(0,19),\
                  (1,0),(1,1),(1,2),(1,3),(1,4),(1,5),\
                  (1,14),(1,15),(1,16),(1,17),(1,18),(1,19),\
                  (2,0),(2,1),(2,2),(2,3),\
                  (2,16),(2,17),(2,18),(2,19),\
                  (3,0),(3,1),(3,2),\
                  (3,17),(3,18),(3,19),\
                  (4,0),(4,1),\
                  (4,18),(4,19),\
                  (5,0),(5,1),\
                  (5,18),(5,19),\
                  (6,0),\
                  (6,19),\
                  (7,0),\
                  (7,19),\
                  (8,0),\
                  (8,19),\
                  (11,0),\
                  (11,19),\
                  (12,0),\
                  (12,19),\
                  (13,0),\
                  (13,19),\
                  (14,0),(14,1),\
                  (14,18),(14,19),\
                  (15,0),(15,1),\
                  (15,18),(15,19),\
                  (16,0),(16,1),(16,2),\
                  (16,17),(16,18),(16,19),\
                  (17,0),(17,1),(17,2),(17,3),(17,4),\
                  (17,16),(17,17),(17,18),(17,19),\
                  (18,0),(18,1),(18,2),(18,3),(18,4),(18,5),\
                  (18,14),(18,15),(18,16),(18,17),(18,18),(18,19),\
                  (19,0),(19,1),(19,2),(19,3),(19,4),(19,5),(19,6),(19,7),(19,8),\
                  (19,11),(19,12),(19,13),(19,14),(19,15),(19,16),(19,17),(19,18),(19,19)]

def intialize_Wafer():
    global sim_Die_FailedList
    global Die_Info_List
    global Die_Canv_List
    
    sim_Die_FailedList=[]
    Die_Info_List=[]
    Die_Canv_List=[]
    #initialize
    i=0
    for r in range(Die_Row):
        for c in range(Die_Column):
    
              Die_Info={}
              Die_Info={"DieNum":i,"row":r,"col":c,"result":"Not Tested"}
              NewDie_x1_loc=Die_x+c*Die_w+Die_xpad
              NewDie_x2_loc=Die_x+Die_w+c*Die_w
              NewDie_y1_loc=Die_y+r*Die_h+Die_ypad
              NewDie_y2_loc=Die_y+Die_h+r*Die_h
              #check if Die cannot be tested
              if((r,c) in Die_Not_Testable):
                Die_Color="gray"
                Die1=canv2.create_rectangle(NewDie_x1_loc,NewDie_y1_loc,NewDie_x2_loc,NewDie_y2_loc,fill=Die_Color)
              else:
                Die_Color="white"
                Die1=canv2.create_rectangle(NewDie_x1_loc,NewDie_y1_loc,NewDie_x2_loc,NewDie_y2_loc,fill=Die_Color)
                Die_Canv_List.append(Die1)
                Die_Info_List.append(Die_Info)
                print (Die_Info_List[i])
                i=i+1
    
    
    canv2.create_oval(0+Die_xpad,0+Die_ypad,Wafer_Width-Die_xpad,Wafer_Height-Die_ypad) #helpful circle to find out side dies
    return

#==================Testing function
def Start_Wafer_Testing():
        intialize_Wafer()
        Pass_cnt=0
        Fail_cnt=0
        Total_cnt=0
        START_Testing['state']="disabled"
        Clear_Wafer['state']="disabled"
        for Die in Die_Info_List:
           if (Stop_Flag==1):
            canv3.itemconfigure(Test_Name_Label,text=("Test -- STOP"),fill='red')
            break
           else:
            #print( Die['DieNum'])
            #test control of on die
            #Move wafer prober to die            
            #Move_Prober_to_Die(Die['row'],Die['col']) a possible function to move prober to Die Position (not focus of this demo)
            Test_Results=[]
            Test_Names=[]
            for Test in Tests_seq:
              Test_result=Test(Die['row'],Die['col'])    #Test Function with its Arguments
              Test_Name=Test.__name__
              print(Test_Name +"  TestResult:         " + Test_result)
              Test_Results.append(Test_result)
              Test_Names.append(Test_Name)
              time.sleep(0.05) #slow it down to see test name
              canv3.itemconfigure(Die_RC_Label,text=(str(Die['row'])+","+str(Die['col'])))
              canv3.itemconfigure(Test_Name_Label,text=(Test_Name +" Result:" + Test_result))
              myWindow.update()


            if((Die['row'],Die['col']) in sim_Die_FailedList):
                 canv2.itemconfigure(Die_Canv_List[Die['DieNum']],fill='red')
                 Die['result']="***Failed***" 
                 Fail_cnt=Fail_cnt+1
                 canv3.itemconfigure(Fail_Bin_count,text=str(Fail_cnt))               
            else:
                 canv2.itemconfigure(Die_Canv_List[Die['DieNum']],fill='lightgreen')
                 Die['result']="Passed"  
                 time.sleep(0.01)
                 myWindow.update()
                 Pass_cnt=Pass_cnt+1
                 canv3.itemconfigure(Pass_Bin_count,text=str(Pass_cnt))
            print("DieInfo",Die)
            Total_cnt=Pass_cnt+Fail_cnt
            canv3.itemconfigure(Total_Bin_count,text=str(Total_cnt))
        Clear_Wafer['state']="normal"
        print ("Failed Dies:",sim_Die_FailedList)  #show failed dies
        
def Clear_Wafer_Result():
        global Stop_Flag
        Stop_Flag=0
        START_Testing['state']="disabled"
        Clear_Wafer['state']="disabled"
        canv3.itemconfigure(Pass_Bin_count,text=str(0))    
        canv3.itemconfigure(Fail_Bin_count,text=str(0))
        canv3.itemconfigure(Total_Bin_count,text=str(0))
        canv3.itemconfigure(Test_Name_Label,text="",fill='white')
        canv3.itemconfigure(Die_RC_Label,text="")
        Show_Result.current(0)
        canv3.itemconfigure(Result_Type_Label,text=myStrVar.get())
        for Die in Die_Info_List:
            print( Die['DieNum'])
            #test control of on die
            canv2.itemconfigure(Die_Canv_List[Die['DieNum']],fill='white')
            myWindow.update()
   
        START_Testing['state']="normal"
        print(Show_Result.get())

def Stop_Wafer_Testing():
    global Stop_Flag 
    Stop_Flag=1
    START_Testing['state']="disabled"
    Clear_Wafer['state']="normal"
    return

def Combobox_Value_Changed(event):
    global myStrVar
    canv3.itemconfigure(Result_Type_Label,text=myStrVar.get())
    Clear_Wafer.focus()
    Show_Map_for(myStrVar.get())  #show wafer this this type failure
    return

def Show_Map_for(strTypeResult):
        #for show only no testing
        Stop_Flag=0
        Pass_cnt=0
        Fail_cnt=0
        subFail_cnt=0
        Total_cnt=0
        Type_Result_Fail={'Overall':'red','OE':'blue','Tx':'orange','Rx':'pink'}
        Type_Result_Fail_List={'Overall':sim_Die_FailedList,'OE':sim_OE_Failure_List,\
                               'Tx':sim_Tx_Failure_List,'Rx':sim_Rx_Failure_List}
        Fail_Color=Type_Result_Fail[strTypeResult]
        for Die in Die_Info_List:
           if (Stop_Flag==1):
            canv3.itemconfigure(Test_Name_Label,text=("Test -- STOP"),fill='red')
            break
           else:
            if(Die['result']!="Not Tested"):   
                if((Die['row'],Die['col']) in sim_Die_FailedList):  #show overall first so user knows it also failed even if not of type selected
                     canv2.itemconfigure(Die_Canv_List[Die['DieNum']],fill='red')  #overall also so user dont not get false thinking
                     Die['result']="***Failed***" 
                     Fail_cnt=Fail_cnt+1
                     canv3.itemconfigure(Fail_Bin_count,text=str(Fail_cnt))
                else:
                     canv2.itemconfigure(Die_Canv_List[Die['DieNum']],fill='lightgreen')
                     Die['result']="Passed"  
                     #NO DELAY for SHOW only  time.sleep(0.01)
                     myWindow.update()
                     Pass_cnt=Pass_cnt+1
                     canv3.itemconfigure(Pass_Bin_count,text=str(Pass_cnt))
                if((Die['row'],Die['col']) in Type_Result_Fail_List[strTypeResult]):           
                     canv2.itemconfigure(Die_Canv_List[Die['DieNum']],fill=Fail_Color)
                     Die['result']="***Failed***" 
                     subFail_cnt=subFail_cnt+1
                     #canv3.itemconfigure(Fail_Bin_count,text=str(Fail_cnt))                
                     canv3.itemconfigure(Result_Type_Label,text=myStrVar.get() +": "+ str(subFail_cnt) +"  color:"+Fail_Color)
                     
                     
                print("DieInfo",Die)
                Total_cnt=Pass_cnt+Fail_cnt
                canv3.itemconfigure(Total_Bin_count,text=str(Total_cnt))
        Clear_Wafer['state']="normal" 


   

START_Testing=Button(frame1, text='START_Test',width=15, command=lambda:Start_Wafer_Testing())
START_Testing.grid(row=0, column=0,padx=10,pady=10)  

Clear_Wafer=Button(frame1, text='Clear',width=15, command=lambda:Clear_Wafer_Result())
Clear_Wafer.grid(row=2, column=0,padx=10,pady=10)

Stop_Wafer=Button(frame1, fg='red',text='STOP',width=15, command=lambda:Stop_Wafer_Testing())
Stop_Wafer.grid(row=3, column=0,padx=10,pady=10)   

#move to row1
myStrVar=StringVar("") #note StringVar is a tkinter variable ,tell tkinter this variable is own by tkinter
Show_Result=Combobox(frame1,textvariable=myStrVar,values=["Overall","OE","Tx","Rx"])
Show_Result.grid(row=1, column=0,padx=10,pady=10)
Show_Result.current(0) #load the Overall as default
Show_Result.bind("<<ComboboxSelected>>",Combobox_Value_Changed)   # a  different way to connect function to event

Result_Type_Label=canv3.create_text(0,10,fill="white",anchor="w",text=myStrVar,font=('Arial',14,''))
canv3.itemconfigure(Result_Type_Label,text=myStrVar.get())   #this is thread save way not myStrVar not myString.get without ()

START_Testing['state']="normal"
Clear_Wafer['state']="disabled"

intialize_Wafer()

#last Line
myWindow.mainloop()

Download for code below

Pyhon_Wafer_Disaply_with_Test_v2 Download

Notes

Presentation: Updated Wafer Display GUI with Pass Fail and Total Die tested to handle Testing functions place holder and showing different test type failures, also a stop. Also a Stop Testing button was added, and ComboBox with binding.
Programming Language used: Python 3.7 in Spyder
Presentation app: Microsoft’s PowerPoint
Python and Tkinter are products of respective company
Presentation shown to spark ideas of use.
This presentation is not connected to or endorsed by any company.
Use at your own risk.
Tags: Python, Python3.7, Tkinter , Canvas ,GUI, List, Dictionary, Tuple for (row,col), Combobox, StringVar,Calling function from List

Posted in Python, Test Sector, tkinter | Tagged Binding, button, Canvas, Canvas Text, Combobox, Function List, GUI, Python, Python3.7, tkinter, Wafer Die GUI example, Wafer Testing example | Leave a comment

Test Engineers Resource

Python – A version of Producer Consumer Pattern with Queues and Threading – Simulated Temp Chamber Demo

InProcess: Python – A version of Producer Consumer Pattern

Tkinter GUI and (non-tk) Matplotlib shrinking the tk GUI

Python – Sequence Editor example

Python – Analog Meter with New Chart-Class this time

Python tkinter and time delay

Python – MCC USB-1208FS-Plus

Python – Learn Queue GUI

Python – Analog Meter GUI example

Python- Updated Wafer Display GUI with Test types

Recent Posts

Categories

Meta