Automated pMOS I-V Data vs Simulations

Caveat: This is a preliminary example to illustrate the opportunity of measuring I-V characteristics. Some comparison is included to the simulated results, but given an public-domain model card is used that is not really optimized for this technology, the matching is not expected to be very good. Some basic analysis was done to try to make simulations match measurements, but it is very limited and incomplete.

Show code cell source

Hide code cell source

import numpy as np
import matplotlib.pyplot as plt
# plt.rcParams['figure.figsize'] = [8.0, 8.0]
%matplotlib inline

import pickle
import os

import PyLTSpice as pyLT

import itertools
colors = itertools.cycle(['b', 'g', 'r', 'c', 'm', 'y', 'k']) 
markers = itertools.cycle(('v', '+', '.', 'o', '*', "s")) 

Show code cell source

Hide code cell source

def plot_data(ax, data, color='b', marker='-o', name='', R_meas=94):
    for i in data.keys():
        VGS = data[i]["VGS"]
        if i == 0:
            ax.plot(data[i]["VDS"], np.array(data[i]["IDS"])*1000/R_meas, marker, color=color, label=name)
        else:
            ax.plot(data[i]["VDS"], np.array(data[i]["IDS"])*1000/R_meas, marker, color=color)
    ax.set_xlabel("VDS [V]")
    ax.set_ylabel("IDS [mA]")
    ax.grid(True)
    ax.legend()

def plot_data_collection(ax, data_collection, R_meas=94):
    for set_name in data_collection.keys():
        plot_data(ax, data_collection[set_name])

pMOS 1x Diode-Connected Devices

There are two diode connected pMOS devices on the chip as part of the current mirrors. We first measure their IDS-VGS characteristics.

Collecting the Simulation Data

Show code cell source

Hide code cell source

sim_filenames = [ "sims/pmos_IV_4x_1x_diode_IDS_VGS.raw" ]
log_filenames = [ "sims/pmos_IV_4x_1x_diode_IDS_VGS.log" ]
LTR = pyLT.RawRead(sim_filenames[0])
LTL = pyLT.LTSpiceLogReader(log_filenames[0])
# step_values = LTL.stepset[LTL.get_step_vars()[0]]
# LTR.get_trace_names()

Show code cell source

Hide code cell source

sim_1x_diode_data = {'sim': {0: {'VGS': 0}}}
sim_1x_diode_data['sim'][0]['VDS'] = (LTR.get_trace("vgs").get_wave())*(-1)
sim_1x_diode_data['sim'][0]['IDS'] = LTR.get_trace("Ix(x12:IN)").get_wave()

Collecting the Measurement Data

Show code cell source

Hide code cell source

folder = './'
# filename = 'nMOS_CM_ids_vds_pm2v5_range.pickle'
filename = 'pMOS_CM_diodes_ids_vds_pm2v5_range.pickle'
file = os.path.join(folder, filename)
if not os.path.exists(file):
    print(f"{file} does not exist -- DATA NOT LOADED")
else:
    with open(file, 'rb') as dbfile_read:
        data_collection_diode = pickle.load(dbfile_read)

Show code cell source

Hide code cell source

data_collection = data_collection_diode
data_collection.keys()

dict_keys(['pMOS_CMlarge_diode', 'pMOS_CM_1x_diode'])

IDS-VGS Measurement vs Simulation

model_scaling = 1.30

Show code cell source

Hide code cell source

colors = itertools.cycle(['b', 'g', 'r', 'c', 'm', 'y', 'k']) 
markers = itertools.cycle(('v', '+', '.', 'o', '*', "s")) 

sim_scaling = model_scaling
no_meas = len(data_collection.keys())
fig, ax = plt.subplots()
for index, name in enumerate(data_collection):
    plot_data(ax, data_collection[name], color=next(colors), marker=next(markers)+'-', name=name, R_meas=94/100)
# ax.get_legend().remove()
# plot_data(ax, sim_1x_diode_data['sim'], marker=next(markers), color=next(colors), name="sim", R_meas=1)
plot_data(ax, sim_1x_diode_data['sim'], marker='-', color=next(colors), name=f'sim_x_{sim_scaling}', R_meas=1/sim_scaling)

ax.set_title('nMOS Diodes: Measurement vs Simulation')
fig.tight_layout()

Observations:

• The transistors are diode connected so VDS=VGS.

• We get a fairly good correspondence between simulation and measurement if we scale the simulation data up.

• This seems to indicate that the mobility is higher on the chip than in the simulation and/or the threshold voltage lower; remember that the model used is a public domain model, not even optimized for this technology.

pMOS Current-Mirror Devices

Here we evaluate the nMOS current mirror, specifically the 1x, 2x, 4x, 8x and 16x devices.

Collecting the Simulation Data

Show code cell source

Hide code cell source

sim_filenames = [ "sims/pmos_IV_4x_1x_IDS_VDS.raw" ]
log_filenames = [ "sims/pmos_IV_4x_1x_IDS_VDS.log" ]
LTR = pyLT.RawRead(sim_filenames[0])
LTL = pyLT.LTSpiceLogReader(log_filenames[0])
step_values = LTL.stepset[LTL.get_step_vars()[0]]
step_values
# LTR.get_trace_names()

[0.75, 1, 1.25, 1.5, 1.75, 2, 2.25]

Show code cell source

Hide code cell source

spice_device_names = {'1x': 'Ix(x12:out1)'} # there is only need for one sim at this point since the scaling is perfect

Show code cell source

Hide code cell source

sim_cm_data = {}
for label, trace_name in spice_device_names.items():
    sim_cm_data[label] = {}
    for step in LTR.get_steps():
        sim_cm_data[label][step] = {}
        sim_cm_data[label][step]['VGS'] = step_values[step]
        sim_cm_data[label][step]['VDS'] = LTR.get_trace("vds").get_wave(step)
        sim_cm_data[label][step]['IDS'] = LTR.get_trace(trace_name).get_wave(step)

Collecting the Measurement Data

Show code cell source

Hide code cell source

folder = './'
filename = 'pMOS_CM_ids_vds_pm2v5_range.pickle'
file = os.path.join(folder, filename)
if not os.path.exists(file):
    print(f"{file} does not exist -- DATA NOT LOADED")
else:
    with open(file, 'rb') as dbfile_read:
        data_collection_cm = pickle.load(dbfile_read)

Show code cell source

Hide code cell source

data_collection = data_collection_cm
data_collection.keys()

dict_keys(['pMOS_CMlarge_1x', 'pMOS_CMlarge_2x', 'pMOS_CMlarge_4x', 'pMOS_CMlarge_8x', 'pMOS_CMlarge_16x'])

model_scaling = 1.30

IDS-VDS Measurement vs Simulation

Show code cell source

Hide code cell source

colors = itertools.cycle(['b', 'g', 'r', 'c', 'm', 'y', 'k']) 
markers = itertools.cycle(('v', '+', '.', 'o', '*', "s")) 

sim_scaling = model_scaling * 1
name = list(data_collection.keys())[0]
fig, ax = plt.subplots()
plot_data(ax, data_collection[name], color=next(colors), marker=next(markers)+'-', name=name, R_meas=94/100)
plot_data(ax, sim_cm_data['1x'], color=next(colors), marker=next(markers)+'-', name=f'sim_x_{sim_scaling}', R_meas=1/sim_scaling)
fig.tight_layout()

Show code cell source

Hide code cell source

colors = itertools.cycle(['b', 'g', 'r', 'c', 'm', 'y', 'k']) 
markers = itertools.cycle(('v', '+', '.', 'o', '*', "s")) 

sim_scaling = model_scaling * 2
name = list(data_collection.keys())[1]
fig, ax = plt.subplots()
plot_data(ax, data_collection[name], color=next(colors), marker=next(markers)+'-', name=name, R_meas=94/100)
plot_data(ax, sim_cm_data['1x'], color=next(colors), marker=next(markers)+'-', name=f'sim_x_{sim_scaling}', R_meas=1/sim_scaling)
# ax.get_legend().remove()
fig.tight_layout()

Show code cell source

Hide code cell source

colors = itertools.cycle(['b', 'g', 'r', 'c', 'm', 'y', 'k']) 
markers = itertools.cycle(('v', '+', '.', 'o', '*', "s")) 

sim_scaling = model_scaling * 4
name = list(data_collection.keys())[2]
fig, ax = plt.subplots()
plot_data(ax, data_collection[name], color=next(colors), marker=next(markers)+'-', name=name, R_meas=94/100)
plot_data(ax, sim_cm_data['1x'], color=next(colors), marker=next(markers)+'-', name=f'sim_x_{sim_scaling}', R_meas=1/sim_scaling)
# ax.get_legend().remove()
fig.tight_layout()

colors = itertools.cycle(['b', 'g', 'r', 'c', 'm', 'y', 'k']) 
markers = itertools.cycle(('v', '+', '.', 'o', '*', "s")) 

sim_scaling = model_scaling * 8
name = list(data_collection.keys())[3]
fig, ax = plt.subplots()
plot_data(ax, data_collection[name], color=next(colors), marker=next(markers)+'-', name=name, R_meas=94/100)
plot_data(ax, sim_cm_data['1x'], color=next(colors), marker=next(markers)+'-', name=f'sim_x_{sim_scaling}', R_meas=1/sim_scaling)
# ax.get_legend().remove()
fig.tight_layout()

Observations:

• The correspondence between measurement and simulation in saturation is remarkably good when the simulation data is scaled up by 30%, especially considering that the public-domain model used is not optimized for this techology.

• The fit in the linear region is less good and reviewed further below.

Current Mirror Scaling

In an ideal current mirror the IDS-VDS characteristic scales with the mirror factor. here we plot the ‘normalized’ currents, so e.g. for the 8x device we plot IDS/8, and so on. To the first order, the characteristics should overlap. (In the layout good practices were applied to get accurate current mirror factors.)

Show code cell source

Hide code cell source

colors = itertools.cycle(['b', 'g', 'r', 'c', 'm', 'y', 'k']) 
markers = itertools.cycle(('v', '+', '.', 'o', '*', "s")) 

no_meas = len(data_collection.keys())
fig, ax = plt.subplots()
for index, name in enumerate(data_collection):
    plot_data(ax, data_collection[name], color=next(colors), marker=next(markers)+'-', name=name, R_meas=94/100*2**index)
ax.set_title('Current Mirror Outputs Scaled to 1x Equivalent')
fig.tight_layout()

Observations:

• In saturation the overlap is very good, especially given the limited accuracy of our setup.

• In the linear region the smaller transistor sizes overlap but the larger transistors do not.

Looking at Parasitic Resistance

In the linear region, especially for the larger devices, the IDS-VDS characteristic measurement is sensitive to possible series resistance since the \(R_{ds}\) of the devices becomes small. We notice that as the VSG increases (and thus the \(R_{ds}\) reduces), the |IDS| does not increase in the linear region, seeming to indicate the presence of a parasitic series resistor. Here we estimate the value of those resistors.

Show code cell source

Hide code cell source

colors = itertools.cycle(['b', 'g', 'r', 'c', 'm', 'y', 'k']) 
markers = itertools.cycle(('v', '+', '.', 'o', '*', "s")) 

no_meas = len(data_collection.keys())
fig, ax = plt.subplots()
for index, name in enumerate(data_collection):
    plot_data(ax, data_collection[name], color=next(colors), marker=next(markers)+'-', name=name, R_meas=94/100*2**index)

colors = itertools.cycle(['b', 'g', 'r', 'c', 'm', 'y', 'k']) 
markers = itertools.cycle(('v', '+', '.', 'o', '*', "s")) 
for res, dev_scale in [(308, 1), (176, 2), (100, 4), (78, 8), (54, 16)]:
    vds = np.arange(0, -2.0, -0.05)
    ids_r = vds/res/dev_scale*1000
    ax.plot(vds, ids_r, '-', color=next(colors), label=f'{dev_scale}x --> {res} Ohm', lw=5, alpha=0.5)

ax.legend()
ax.set_title('Current Mirror Outputs Scaled to 1x Equivalent \n and Resistors')
ax.set_xlim((-1.0, 0))
ax.set_ylim((-2.5, 0))
fig.tight_layout()

Show code cell source

Hide code cell source

colors = itertools.cycle(['b', 'g', 'r', 'c', 'm', 'y', 'k']) 
markers = itertools.cycle(('v', '+', '.', 'o', '*', "s")) 

no_meas = len(data_collection.keys())
fig, ax3 = plt.subplots(no_meas, figsize=(7,10))
for index, name in enumerate(data_collection):
    ax=ax3[index]
    color=next(colors)
    marker=next(markers)
    plot_data(ax, data_collection[name], color=color, marker=marker+'-', name=name, R_meas=94/100)
    res, dev_scale = [(308, 1), (176, 2), (100, 4), (78, 8), (54, 16)][index]
    vds = np.arange(-1.0, 0.05, 0.05)
    ids_r = vds/res*1000
    ax.plot(vds, ids_r, '-', color=color, label=f'{dev_scale}x --> {res} Ohm', lw=5, alpha=0.5)
    ax.set_xlim((-1.0, 0))
    # ax.set_ylim((-2.5, 0))
    ax.legend()

plt.suptitle('Current Mirror Outputs and Resistors')

fig.tight_layout()

Observations:

• There are series resistors placed for ESD reasons on the pins (e.g. \(\approx 12.5\Omega\) for the 8x device, see chip description), but they were nominally designed to be smaller than the values found here.

• Possibly additional routing parasitics or measurement parasitics play a role here.