Using Cyckei

First Launch

Upon first launch, Cyckei will create a cyckei directory in the user’s home folder to hold scripts, test results, logs, and configuration. Before running tests, Cyckei must be configured to properly interface with any devices. Each channel should be setup in the config.json file with the correct GPIB address and any other relevant information. A default configuration is automatically generated, and instructions on further configuration can be found in the Editing Configuration section.

Starting a cycle

Various attributes of the cycle must be set in order to start a cycle. All of these have default values to prevent errors, however it is a good idea to manually specify them. The following should be set under the desired channel:

Option Type Description Default
Script dropdown Script with desired protocol. Automatically loaded from the ‘cycleScripts’ folder in the program’s root directory. First scanned file
Cell ID text Identification for cell. Recorded to output file. 0
Log file text Path to output file. Placed in the specified logs folder. “defaultLog.txt”
Mass text Mass of cell. 1
Comment text Requester’s comment for cycle. Recorded to output file. “No Comment”
Package type dropdown Type of cell package. Recorded to output file. “Pouch”
Cell type dropdown Type of cell. Recorded to output file. “Full”
Requester dropdown Name of person starting cycle. “Unspecified”

The available buttons can be used to Start, Stop, Pause, or Resume the protocol. Note that the program will overwrite any existing output files if an identical log file is specified. The Fill button allows you to automatically create a log file name based on the entered cell ID. This takes the format of [id]A.pyb where the “A” designates which log file within a series.

Creating Scripts

Scripts can be created in the scripts tab of the client. This editor will automatically load the default included scripts, but can be used to open and edit additional files.

Scripts are written in regular python code, and can contain loops and other statements to control cycle flow. There are seven built in protocols to control the cycler. Most of these protocols take some or all of the following parameters:

Parameter Description Format
Value Set a certain voltage or current to run at. float
Reports Set intervals of time and/or change in voltage or current to record at. reports=((“current”, float), (“time”, “int:int:int”))
Ends Set threshold of time and/or change in voltage or current to end current protocol. ends=((“current”, “<”, float), (“time”, “>”, “int:int:int”))

The following protocols are available:

Protocol Description Parameters Example
AdvanceCycle Start recording under next cycle in output file. None AdvanceCycle()
CCCharge Charge at a set current. Value, Reports, Ends CCCharge(0.1, reports=((“voltage”, 0.01), (“time”, “:5:”)), ends=((“voltage”, “>”, 4.2), (“time”, “>”, “4::”)))
CCDischarge Discharge at a set current. Value, Reports, Ends CCDischarge(0.1, reports=((“voltage”, 0.01), (“time”, “:5:”)), ends=((“voltage”, “<”, 3.0), (“time”, “>”, “4::”)))
CVCharge Charge at a set voltage. Value, Reports, Ends CVCharge(4.2, reports=((“current”, 0.01), (“time”, “:5:”)), ends=((“current”, “<”, 0.005), (“time”, “>”, “24::”)))
CVDischarge Discharge at a set voltage. Value, Reports, Ends CVDischarge(4.2, reports=((“current”, 0.01), (“time”, “:5:”)), ends=((“current”, “<”, 0.005), (“time”, “>”, “24::”)))
Rest Record at a set interval. Reports, Ends Rest(reports=((“time”, “::1”),), ends=((“time”, “>”, “::15”),))
Sleep Record at a set interval and turn channel off in between. Reports, Ends Sleep(reports=((“time”, “:1:0”),), ends=((“time”, “>”, “::15”),))

An example script is shown below. There is also a simple script saved in the scripts folder which is available whenever the client is started.

for i in range(3):
  AdvanceCycle()
  CCCharge(0.1, reports=(("voltage", 0.01), ("time", ":5:")), ends=(("voltage", ">", 4.2), ("time", ">", "4::")))
  CCDischarge(0.1, reports=(("voltage", 0.01), ("time", ":5:")), ends=(("voltage", "<", 3.0), ("time", ">", "4::")))
  Rest(reports=(("time", "::1"),), ends=(("time", ">", "::15"),))

Scripts are automatically checked when they are sent to the server. They can also be manually checked by clicking the “Check” button in the scripts tab. Checking a script ensures that (1) the script only contains legal arguments and (2) can be loaded by the server without immediate errors. Checking your scripts is a good practice to mitigate possible formatting issues and errors. However, care should still be taken while writing scripts as they are executed as any other python code within the application.

Working With Batches

The “Batch” menu allows large tests with multiple cells to be run more easily. Saving a batch writes the IDs and log files of each channel to the “batch” file which can be loaded later. The “Fill All” and “Increment” options allow you to automatically create log files based on each ID, and increment the last letter to indicate which test is being run on the same cell.

Viewing Logs

Logs are created to document measurements from each cell throughout it’s cycle. They also have details about the cell and the cycle that was run on it. Log files are saved to the “tests” folder specified in the configuration under the specified name. To view a log from the client application, just open the logging tab. All logs are automatically loaded on startup, and new or updated ones can be viewed after clicking reload. Although you can copy the contents of a log file to an excel spreadsheet, log files should not be opened with excel or another application directly. Doing this can cause the file to become locked and prevent Cyckei from editing it.

Editing Configuration

Editing the configuration file is crucial for the client to function properly. Any custom configuration files should be written in JSON and should mirror the default config.json in the program’s root directory. Each section is described in more detail below:

  • channels - A list of channels currently connected to the computer.
    • channel (string) - Channel number for identification within the application.
    • gpib_address (int) - Hardware address of GPIB interface can be found with a NI VISA application or wth the code in Host System Setup.
    • keithley_model (string) - Model number of keithley being used.
    • keithley_channel (string) - Particular channel on said keithley (a or b).
  • zmq - A dictionary of properties that control how the client and server communicate.
    • port (int) - Port to communicate over.
    • client-address (string) - Address for the client to connect to. Usually localhost.
    • server-address (string) - Address for the server to listen on. Usually all.
    • timeout (int) - Number of seconds to wait for server response. 10 seconds seems to work well for most configurations.
  • verbosity - The amount of information to be saved to log files. Generally should be set to 20, but the following levels can also be used. Lower values print more information for debugging purposes.
    • Critical - 50
    • Error - 40
    • Warning - 30
    • Info - 20
    • Debug - 10
    • Notset - 0

Here is an example configuration file for a simple setup running on port 5556 with one Keithley with address 5:

{
    "channels": [
        {
            "channel": "1",
            "gpib_address": 5,
            "keithley_model": "2602A",
            "keithley_channel": "a"
        },
        {
            "channel": "2",
            "gpib_address": 5,
            "keithley_model": "2602A",
            "keithley_channel": "b"
        }
    ],
    "zmq":{
        "port": 5556,
        "client-address":"tcp://localhost",
        "server-address":"tcp://*",
        "timeout": 10
    },
    "verbosity": 20,
}