Generator tests for chip (ИР11). МАИ. Кафедра 307.

chip test ir11.py

#!/usr/bin/env python2
# -*- coding: utf-8 -*-
#-------------------------------------------------------------------------------
# Short desc:  Generator tests for chip (ИР11)      
# Author:      ahmpro
# Created:     18.04.2013
#-------------------------------------------------------------------------------


class IR11:
    sync = 0
    conn = [
        "-R", "DSR", "D0", "D1", "D2", "D3", "DSL", "GND",
        "S0",  "S1",  "C", "Q3", "Q2", "Q1",  "Q0",  "5V",
    ]
    ports = {}
    broken = []
    states = []

    def __init__(self, broken = None):
        self.ports = {}
        self.states = []
        self.broken = [] if broken is None else broken

        for p in self.conn:
            self.down(p)
            
        self.reset()

    def reset(self):
        self.down("-R")
        self.up("5V")

        self.save_state()
        self.up("-R")
        

    def save_state(self):
        pin = {}
        for p in self.conn:
            pin[p] = self.g(p)

        if pin["-R"] == 0:
            pin["Q0"], pin["Q1"], pin["Q2"], pin["Q3"] = 0, 0, 0, 0

        elif not (self.sync == 0 and pin["C"] == 1):
            pass # delay

        elif pin["S0"] == 1 and pin["S1"] == 1:
                pin["Q0"] = pin["D0"]
                pin["Q1"] = pin["D1"]
                pin["Q2"] = pin["D2"]
                pin["Q3"] = pin["D3"]

        elif pin["S0"] == 0 and pin["S1"] == 1:
                pin["Q0"] = pin["Q1"]
                pin["Q1"] = pin["Q2"]
                pin["Q2"] = pin["Q3"]
                pin["Q3"] = pin["DSL"]

        elif pin["S0"] == 1 and pin["S1"] == 0:
                pin["Q3"] = pin["Q2"]
                pin["Q2"] = pin["Q1"]
                pin["Q1"] = pin["Q0"]
                pin["Q0"] = pin["DSR"]
                

        self.sync = pin["C"]

        for q in ["Q0","Q1","Q2","Q3"]:
            if q in self.broken:
                pin[q] = 1

        state = []
        for p in self.conn:
            state.append(pin[p])
            self.ports[p] = pin[p]
        self.states.append(state)

    def g(self, port):
        return 1 if port in self.broken else self.ports[port]

    def set_p(self, port, value):
        self.ports[port] = value

    def up(self, port):
        self.set_p(port, 1)

    def down(self, port):
        self.set_p(port, 0)

    def soft_reset(self):
        dont_touch = ["-R", "GND", "5V", "Q0", "Q1", "Q2", "Q3"]

        for p in self.conn:
            if p not in dont_touch:
                self.down(p)

    def load(self, D):
        self.soft_reset()

        self.up("S0")
        self.up("S1")

        self.set_p("D0", D[0])
        self.set_p("D1", D[1])
        self.set_p("D2", D[2])
        self.set_p("D3", D[3])

        self.sync_up()

    def delay(self):
        self.soft_reset()

        self.down("S0")
        self.down("S1")

        self.down("D0")
        self.down("D1")
        self.down("D2")
        self.down("D3")

        self.save_state()

    def shift_left(self, bit):
        self.soft_reset()

        self.down("S0")
        self.up("S1")
        self.set_p("DSL", bit)

        self.sync_up()

    def shift_right(self, bit):
        self.soft_reset()

        self.down("S1")
        self.up("S0")
        self.set_p("DSR", bit)

        self.sync_up()

    def sync_up(self):
        self.down("C")
        self.save_state()
        self.up("C")
        self.save_state()



class Test:
    bits = []
    test = []
    resistors = []
    name = ""
    caption = ""
    outs = []

    def __init__(self, name, caption, outs, raw):
        i2s = lambda lst: map(str, lst)

        self.name = name
        self.caption = caption
        self.outs = outs

        mask = [1]*16
        for out in outs:
            mask[out] = 0

        self.mask = i2s(mask)

        for one in raw:
            r = [0]*16
            t = ['x']*16

            self.bits.append(i2s(one))
            self.test.append(i2s(t))
            self.resistors.append(i2s(r))

    def save(self, f):
        h = open(f, 'w')
        h.write('<head korpus="DIP16" pincount="16" name="%s">\n' % self.name)
        h.write('<names caption="%s">\n' % ", ".join(self.caption))
        h.write('<confa1            mask="%s">\n' % ", ".join(self.mask))
        for i in range(len(self.bits)):
            h.write('<id%s  type="infa"  bits="%s"\n' % (i+1, ", ".join(self.bits[i])))
            h.write('                   test="%s"\n' % ", ".join(self.test[i]))
            h.write('              resistors="%s">\n' % ", ".join(self.resistors[i]))
        h.close()

    def apply_broken(self, raw, k, f):
        i2s = lambda lst: map(str, lst)
        
        for i in range(len(raw)):
            t = ['x']*16

            for out in self.outs:
                t[out] = raw[i][out]
            self.test[i] = i2s(t)

        name = self.name
        self.name = "%s, wrong %i pin" % (self.name, k)
        self.save(f % k)
        self.name = name



def sequence(chip):
    chip.load([0,0,0,0])
    chip.load([1,0,0,0])
    chip.reset()
    chip.load([0,0,0,1])
    chip.load([0,1,0,0])
    chip.load([0,0,1,0])
    chip.shift_left(0)
    chip.shift_left(1)
    chip.delay()
    chip.shift_right(0)
    chip.shift_right(1)
    chip.shift_right(0)

def run():
    sym3 = lambda s: "%3s" % s
    pretty = lambda lst: ", ".join(map(sym3, lst))

    print("-* Chip:")
    chip = IR11()

    sequence(chip)

    print(pretty(range(1,17)))
    print(pretty(chip.conn))
    for i in range(len(chip.states)):
        print(pretty(chip.states[i]))

    test = Test("DIP16, IR11, 03-320, Klimanov", chip.conn, [11,12,13,14], chip.states)
    test.save("_klimanov_ir11.cfa")

    print("-* Wrong:")

    for i in range(16):
        broken = chip.conn[i]

        if broken not in ["GND", "5V"]:
            wrong = IR11([broken])
            sequence(wrong)
            test.apply_broken(wrong.states, i+1, "_klimanov_ir11_w%i.cfa")
            del wrong


if __name__ == '__main__':
    run()