This guide is meant as a walk through the various steps needed to set up and use the wafer-level testing software.
Setting up the software
This section describes how to install and prepare croc_wlt before using it.
Installing the dependencies
Most of the requirements of croc_wlt get installed automatically when
installing the package via setuptools
. Some requirements, however, must be
installed manually.
Ph2_ACF
The DAQ software (Ph2_ACF
) version used for waferprobing can be found at the
following GitLab page.
power_supply
At the moment, the power_supply
library is required to perform some tests from
Ph2_ACF
. The power_supply
server must be running.
The software version employed for wafer-level testing can be found at the following GitLab page.
This dependency is planned to be removed in a future version of croc_wlt.
Linux GPIB
The probe station library in wlt/hardware/probe_station
requires the Linux
GPIB library to be installed. The version used is the 4.1.0, which
can be found on SourceForge.
CERN ROOT
The CERN ROOT framework is used in croc_wlt for producing wafer maps and, in
the future, to perform data analysis. The version used is the 6.22.08
; it can be
found on GitHub.
Installing the package
In order to use croc_wlt, the Python package must be first installed using
the setuptools
package. In order to
do so, the following command must be run in the root folder of the package (the
one with the setup.py
file):
$ python setup.py develop
The optional setuptools
parameter install-dir
can be used in order to
manually set the location for installing the package (such as
.local/lib/python3.7/site-packages
):
$ python setup.py develop [--install-dir PATH/TO/INSTALL/DIR]
Installing the package in development mode allows the user to change the code
and run it without reinstalling the package (more information can be found
in the setuptools
guide).
Should it be needed, the package can be later uninstalled by running:
$ python setup.py develop --uninstall [--install-dir PATH/TO/INSTALL/DIR]
Setting up the environment
After installing the package in development mode, the setup.sh
Bash script
must be configured with the location of the Ph2_ACF
installation needed. In
order to do so, the ACF_LOCATION
variable must be edited with the correct
path.
The setup.sh
Bash script, in turn, sources Ph2_ACF
's setup script. It also
exports the following environment variables:
-
WLT_DIR
: root folder of the package; -
DAQ_DIR
: folder with DAQ data (configuration files etc.); -
DATA_DIR
: folder in which the WLT data will be stored.
After editing it as described above, the script must be sourced with the following command:
$ source setup.sh
Running the software
This section describes how to use croc_wlt to test chips.
Common configuration
The configuration for the croc_wlt package can be found in the config
subpackage. The wlt/config/main_config.py
module contains the configuration for
ChipTester
, WaferTester
, the WPAC and more.
First, the type of the chip under test must be defined by editing the
CHIP_TYPE
variable as needed:
CHIP_TYPE = CROC_CHIP
Valid values are RD53A_CHIP
and CROC_CHIP
, which are global variables for
the wlt
package. The latter is also currently used for RD53B-ATLAS testing, as
the testing routines are the same at the moment.
Local wafer inventory
During the efuses
test a unique EFUSE code
is generated for a chip, which is written directly to the chip and stored in the DCA database as Serial number
to identify every chip during construction and operation of the detector. It is in turn generated based on the unique Serial number
of the wafer, which has to be known before starting the test.
All the relevant IDs of each registered wafer are stored in a local SQLite
file, which has to be up to date with the wafers registered in the DCA database. If the wafer being tested is not present in the local SQLite
file, the chip Serial number
can't be generated and the efuses
test will fail.
The local SQLite
file can be updated by executing the wlt/db_reader.py
script twice:
# Insert all CROCv1 Proto wafers (existing file will be overwritten)
python3 wlt/db_reader.py -w "+*" -s db_file.sqlite -p
# Append all CROCv2 wafers
python3 wlt/db_reader.py -w "+*" -s db_file.sqlite+
NOTE: Add option
-2
if your CERN account uses 2FA (2-Factor Authentication).
WPAC settings
The WPAC_CONF
dictionary should be edited as needed in order to set the
configuration for the WPAC.
The port
key should contain the path to the device
file for the RS-232 communication with the WPAC (this is not the programming
port used when uploading the firmware to the board).
The value of the baud_rate
key depends on the baud rate set in the WPAC
firmware. Unless the value is explicitly changed in the firmware, this shouldn't
be edited.
The termination
key sets the termination character for the serial
communication with the WPAC. Unless the value is explicitly changed in the
firmware, this shouldn't be edited.
The timeout
key represents the timeout (in seconds) for the WPAC
communication. As no problems have been observed with the default value of 1
second, it is suggested to avoid reducing it. Unless the termination character
is explicitly changed in the firmware, this shouldn't be edited.
The chip_type
key is automatically set to the global configuration variable
CHIP_TYPE
, so there should be no need to change the default value.
Power supply and source-meter unit settings
The settings for the instruments used during wafer-level testing can be found in
the "power supplies" section of config/main_config.py
.
The DEVICES
dictionary contains the configuration for the instruments. The
names of the keys for each configuration dictionary (PC
, AUX
, ...) should
not be edited.
The SIGNALS
dictionary represents the mapping between signal names (e.g.,
VINA) and instrument channels. It is recommended to not change the wiring of the
different signals and to leave the defaults here.
Testing a chip
Configuration
The behaviour of chiptester
can be configured by editing the config/main_config.py
configuration module. All the settings directly relevant to chiptester
can be
found in the ChipTester section.
The TESTS_LIST
dictionary can be used to select which tests to perform when
running chiptester
.
The TESTS_CONF
dictionary contains the configuration for each test.
The CHIPTESTER_CONF
dictionary contains the settings for setting up the
ChipTester
class, such as the chip serial number (chip_sn
).
Starting the test
In order to test a chip, the main of the chiptester
module must be run:
$ python chiptester.py
The logs and json data can be found in the data/chips
folder at the end of the
testing.
The CTRL+C command can be sent during the testing phase in order to stop the execution. The command is catched and cleanup is performed before closing the program (power supplies are reinitialized, the probe card is reset, ...). The use of CTRL+C should be limited however.
Testing a wafer
Configuration
The behaviour of wafertester
can be configured by editing the config/main_config.py
configuration module. The relevant settings can be found in the WaferTester
section. The WAFERTESTER_CONF
contains all the configurations for the WaferTester
class.
Settings available in WAFERTESTER_CONF
:
-
wafer_sn
: serial number of the wafer; -
chip_type
: automatically set to theCHIP_TYPE
global variable; -
start_column
,start_row
: column and row indices for the starting die; -
n_chips_test
: number of chips to test; -
gpib_address
: GPIB address for the communication with the probe station; -
mov_wait_time
: number of seconds to wait for probe station movements; -
log_level
: threshold for logging entries; -
test_chips
: boolean which defines whether to test chips (True) or not. If set to False, only the so-called wafer travel is performed; -
separate_after_test
: get to separation height (True) or not at the end of the testing procedure; -
metadata
: information relevant for waferprobing, such as the operator, hardware used and so on. This information will be stored in the waferprobing JSON; -
double_contact
: contact the chip twice before starting the testing. This procedure can reduce the contact resistance.
Running the test
After setting the relevant configuration in config/main_config.py
, the testing can
be started by running:
$ python wafertester.py
The results of the testing can be found in the data
folder. A subfolder with
the wafer SN is created and, inside it, a subfolder with the time at which the
run has been started can be found. Logs and json data can be found within this
folder.
Visualising the test results
A dedicated set of validation plots for a given run stored in <RUN_FOLDER>
can be
produced by running:
$ python waferanalyzer.py <RUN_FOLDER>
By default the plots configured in wlt/config/analyzer_config.py
will be produced
and stored in <RUN_FOLDER>/plots
. A different configuration file or output folder
can be set via command-line parameters.
In addition to overview histograms with 1 PDF/plot, more complex distribution with
1 PDF/chip are stored in <RUN_FOLDER>/plots/chips
. Two summary PDF files combining
all the wafer-overview and chip-specific plots are stored in
<RUN_FOLDER>/plots/summary
.
If only individual JSON files from the chiptester have to be processed instead of a complete wafer test, they can be analysed using:
$ python jsonplotter.py <file1.json> [<fileN.json>]
with plots stored in the ./plots
folder.
No wafer-level processing is performed in this case.
Low-level documentation
The source code is documented using Python docstrings. This lower-level
documentation can be read directly in the source code or by using the
pydoc
tool.