wxGestalt
wxGestalt is a very, very simple IDE for controlling Gestalt nodes in Python. The IDE lets you (more easily) configure the machine, connect to it, and create a GUI for controlling it. It is very, very experimental, so if you experiment with it, please share your impressions as Issues on its GitHub repository.
In order to develop it, I studied a bit the Gestalt library, so I extracted its basic documentation with Sphinx; it is available here if you want to know how it works. The library is very powerful, but it seems that for what we need to do in the Fab Academy this example has everything.
Please note #01:
With Gestalt nodes you can create endless configurations, so the IDE will just make it easier for you to create your own script that controls the machine. It is impossible to create a "universal" app for the Gestalt... or it would take too much time at the moment. Furthermore, it should be part of your exercise to write code for it! :)
Please note #02:
The code that you have to write in the IDE is Python + wxPython. You just have to write a wx.Panel object, see the template for an example.
Please note #03:
Currently wxGestalt lets you add only 4 nodes. This can be easily modified in the GUI code of wxGestalt. If you need more nodes, let me know and I'll fix it.
01. Install wxGestalt
Most likely wxGestalt won't have any packaged installer for a while. For the moment, you should jump in its development directly! wxGestalt uses at the moment Ilan Moyer's Gestalt, installed as a Git submodule. So, you will have to install it in this way:
- git clone https://github.com/openp2pdesign/wxGestalt.git
- cd wxGestalt
- git submodule update --init gestalt
Git will then dowload the Gestalt library inside the wxGestalt folder. You then have to install the dependencies for wxGestalt:
- wxPython: check for your OS
- pip install PySerial
- pip install unidecode
- pip install jsonpickle
01. How it works
There are many tabs in wxGestalt, they are supposed to be used according to the number, so let's start with the first tab. It is needed in order to configure the machine. At the moment it is very simple, but there are more settings under development:
In the second tab you can identify the nodes, as you would do in any of examples. It basically redirects the terminal to the screen. Click on the "Initialize the machine" button to launch the identification.
The third tab is the IDE: you can write the Python code that will control the machine. The IDE loads by default a template (see below), but you can open any Python file and save your script as a Python file. When you save the machine (File > Save the machine) the code will be embedded in the machine file, so you can reload in the future. The machine file is a JSON file, so if you want to edit your Python file in another IDE, you'd probably want to save the script as an external file and then load it. When you click on the "Launch the script", a new tab will be opened. That tab will be generated from your code!
02. Template
wxGestalt provides you a template file (in Python) for developing a wxPython panel that will control the machine. The file can be accessed here or here. Here's the code:
| # -*- coding: utf-8 -*- | |
| # License: Public Domain (use it as you like!) | |
| # Import main wxPython libraries | |
| import wx | |
| import wx.xrc | |
| # Import the wxGestalt module for Gestalt Machines | |
| import Machines.wxMachines as wxMachines | |
| ########################################################################### | |
| ## Class wxGestaltPanel | |
| ########################################################################### | |
| class wxGestaltPanel(wx.Panel): | |
| ''' | |
| This is the main class for the app that will be launched in the fifth tab. | |
| Do not rename the class, or wxGestalt won't open it in the tab. | |
| Please remember: if you print anything, it will go out to the second tab | |
| (2. Identify the nodes). So please add a text widget and update its value | |
| in order to show some text / values in the GUI. | |
| ''' | |
| def __init__( self, parent ): | |
| ''' | |
| This function initialize the interface. Add all your GUI elements here. | |
| The self.myMachine object is the machine you initialized in the first two tabs. | |
| Don't change it or it won't work. The self.launch_button will launch your | |
| code, change only its position. | |
| ''' | |
| # Initialize the panel that contains all the GUI elements | |
| # Don't change this! | |
| wx.Panel.__init__ ( self, parent, id = wx.ID_ANY, | |
| pos = wx.DefaultPosition, size = wx.Size( 500,300 ), | |
| style = wx.TAB_TRAVERSAL ) | |
| # Load the machine edited in the main app. | |
| # Don't change this! | |
| self.myMachine = self.GetParent().myMachine | |
| # Create sizers for organizing the GUI elements here | |
| self.mainSizer = wx.BoxSizer( wx.VERTICAL ) | |
| # ... | |
| # Create GUI elements here | |
| txt1 = "Just a text element to show you how to create GUI widgets..." | |
| st1 = wx.StaticText(self, label=txt1, style=wx.ALIGN_CENTRE) | |
| # ... | |
| # Add GUI elements to the sizer here | |
| self.mainSizer.Add(st1, flag=wx.ALL, border=5) | |
| # ... | |
| # Bind events to GUI widgets here | |
| # ... | |
| # Add a button for launching your app. | |
| # You should only change the position of this! | |
| self.launch_button = wx.Button( self, wx.ID_ANY, u"Run", wx.DefaultPosition, wx.DefaultSize, 0 ) | |
| self.mainSizer.Add( self.launch_button, 0, wx.ALL, 5 ) | |
| self.launch_button.Bind( wx.EVT_BUTTON, self.On_Run ) | |
| # Set up sizers and layout | |
| # Don't change this! | |
| self.SetSizer( self.mainSizer ) | |
| self.Layout() | |
| def On_CalculateMoves(self): | |
| ''' | |
| Add here the function for calculating the move instructions to be sent to the machine. | |
| ''' | |
| # Add here your algorithm | |
| # ... | |
| # Store here the final moves from your algorithm | |
| # The code below is just an example on how to structure the moves | |
| # according to the number of nodes | |
| if self.myMachine.nodesNumber == 1: | |
| moves = [[10],[20],[10],[0]] | |
| elif self.myMachine.nodesNumber == 2: | |
| moves = [[10,10],[20,20],[10,10],[0,0]] | |
| elif self.myMachine.nodesNumber == 3: | |
| moves = [[10,10,10],[20,20,20],[10,10,10],[0,0,0]] | |
| elif self.myMachine.nodesNumber == 4: | |
| moves = [[10,10,10,10],[20,20,20,20],[10,10,10,10],[0,0,0,0]] | |
| # Return the value | |
| return moves | |
| def On_Run(self, event): | |
| ''' | |
| This function will finally control the machine after you press the "Run" button. | |
| Do not change this function. | |
| ''' | |
| # This will calculate the moves for your machine | |
| moves = self.On_CalculateMoves() | |
| # This will send the moves to the machine | |
| self.myMachine.moveMachine(moves) |
03. moves
The moves data to be sent to machine is just a Python list, where each element is another list. The number of the elements inside this second list is determined by the number of nodes. See for example:
- 1 node: moves = [[10],[20],[10],[0]]
- 2 nodes: moves = [[10,10],[20,20],[10,10],[0,0]]
- 3 nodes: moves = [[10,10,10],[20,20,20],[10,10,10],[0,0,0]]
- 4 nodes: moves = [[10,10,10,10],[20,20,20,20],[10,10,10,10],[0,0,0,0]]
04. Repository
Clone, forks, pull requests, issues on https://github.com/openp2pdesign/wxGestalt
