chipscopy.api.ibert.eye_scan

chipscopy.api.ibert.create_eye_scans(*, target_objs)

Create an instance of EyeScan and attach it to the eye_scan attribute of the target_obj (s)

Parameters:

target_objs (Union[RX, Link, List[RX, Link]]) – The object to use for attaching the eye scan instance. The object must be an instance of RX or Link class.

Return type:

QueryList[EyeScan]

Returns:

List of eye scan object(s) created

chipscopy.api.ibert.delete_eye_scans(scans_to_delete=None)

Delete EyeScan object(s) that were created previously

Parameters:

scans_to_delete (Union[EyeScan, List[EyeScan], QueryList[EyeScan], None]) – (Optional) Eye scan object(s) to delete.

Warning

If no eye scan objects are provided, all available eye scans are deleted.

chipscopy.api.ibert.get_all_eye_scans()

Get all EyeScan object(s)

Return type:

QueryList[EyeScan]

Returns:

List of eye scan object(s)

class chipscopy.api.ibert.eye_scan.EyeScan(rx, name, params=<factory>, done_callback=None, progress_callback=None, error='', filter_by=<factory>, status='Not Started', progress=-1.0, stop_time=None, start_time=None, elf_version=None, data_points_read=0, data_points_expected=0, open_data_points=0, scan_data=None, metric_data=None, plot=None, _handle_from_cs_server=None, _scan_done_event=<factory>)

Class for interacting with eye scans. Please do not create an instance of this class directly. Please use the factory method create_eye_scans() instead.

data_points_expected: int = 0

Total number of data points expected to be scanned by the MicroBlaze

data_points_read: int = 0

Number of data points scanned by the MicroBlaze

done_callback: Callable[[EyeScan], None] = None

Callback function called when eye scan has ended

elf_version: str = None

ELF version read from the MicroBlaze

error: str = ''

String detailing reason for scan abort

filter_by: Dict[str, Any]

generate_report()

Generate a report for this eye scan object and send it to the “printer” for printing

invalidate()

metric_data: MetricData = None

metric data stored in an instance of MetricData class

name: str

Name of the eye scan

open_data_points: int = 0

Number of data points scanned by the MicroBlaze

params: Dict[str, EyeScanParam]

Dictionary containing the py:class:EyeScanParam instance for every available param

plot: EyeScanPlot = None

EyeScanPlot instance for interacting with the plot

progress: float = -1.0

Progress of the eye scan in %

progress_callback: Callable[[float], None] = None

Callback function called when eye scan update is received

rx: RX

RX object attached to this eye scan

scan_data: ScanData = None

Scan data stored in an instance of the ScanData class

start(*, show_progress_bar=True)

Send command to cs_server to start the eye scan in the HW.

Parameters:

show_progress_bar (bool) – Set to true to show progress bar on stdout

start_time: datetime = None

Time stamp of when eye scan was started in cs_server

status: str = 'Not Started'

Status of the eye scan

stop()

Stop eye scan, that is in-progress in the MicroBlaze

stop_time: datetime = None

Time stamp of when eye scan was stopped in cs_server

wait_till_done()

Block current thread execution till the eye scan completes OR it is aborted by cs_server/HW.

class chipscopy.api.ibert.eye_scan.MetricData(open_area, open_percentage, horizontal_opening, horizontal_percentage, vertical_opening, vertical_percentage)

Class for storing scan metric data

horizontal_opening: int

zero offset horizontal opening of the eye scan

horizontal_percentage: float

zero offset horizontal opening percent of the eye scan

open_area: int

open area in the eye scan

open_percentage: float

open area percentage of the eye scan

vertical_opening: int

zero offset vertical opening of the eye scan

vertical_percentage: float

zero offset horizontal opening percent of the eye scan

class chipscopy.api.ibert.eye_scan.Plot2DData(scan_points, ber_floor_value)

ber_floor_value: float

This value is used as the ber value for any X, Y coordinate whose computed BER was 0

scan_points: Dict[Tuple[int, int], ScanPoint]

Collection of ScanPoint instances to represent the 2D eye scan plot

class chipscopy.api.ibert.eye_scan.RawData(ut, prescale, error_count, sample_count, vertical_range, horizontal_range)

Class for storing raw data from the MicroBlaze. The size of all the lists in this class will be the same

error_count: List[int]

horizontal_range: List[int]

prescale: List[int]

sample_count: List[int]

ut: List[int]

vertical_range: List[int]

class chipscopy.api.ibert.eye_scan.ScanData(raw, all_params, processed=None)

Class for storing raw scan data and 2D plot data

all_params: dict

All parameters the server used to run the scan in the MicroBlaze

processed: Plot2DData = None

2D plot data. This will only be available if the scan completed successfully

raw: RawData

Raw scan data from the MicroBlaze

class chipscopy.api.ibert.eye_scan.ScanPoint(x, y, ber, errors, samples)

ber: float

errors: int

samples: int

x: int

y: int