KaptureControlGui/KCG/base/bitsTable.py

"""
This defines the Tables used as Bits display
"""

from PyQt4 import QtGui, QtCore
import logging
from backend import board
from backend.board import available_boards
import backendinterface as bif
import kcgwidget as kcgw
tr = kcgw.tr

class BitsDisplayTable(QtGui.QTableWidget):
    """
    Widget to use to display the Bits (as table)
    """
    def __init__(self, value, parent=None, optimalSize=True):
        QtGui.QTableWidget.__init__(self, parent)
        self.numbers = str(value)
        if len(self.numbers) == 0:
            raise ValueError("Cant create a table for a value of length 0.")
        self.length = len(self.numbers)
        self.do_style()
        if optimalSize is True:
            self.do_optimal_size()

    def do_style(self):
        self.horizontalHeader().setDefaultSectionSize(35)
        self.horizontalHeader().setResizeMode(QtGui.QHeaderView.Fixed)
        self.horizontalHeader().setVisible(True)
        self.verticalHeader().setDefaultSectionSize(17)
        self.verticalHeader().setResizeMode(QtGui.QHeaderView.Fixed)
        self.verticalHeader().setVisible(False)
        self.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
        self.setRowCount(1)
        self.setColumnCount(self.length)

        # If self.length would be 5, this line would generate ('4', '3',
        # '2', '1', '0')
        headers = tuple([str(i) for i in reversed(range(0, self.length))])
        self.setHorizontalHeaderLabels(headers)

        for i in range(len(self.numbers)):
            item = QtGui.QTableWidgetItem(self.numbers[i])
            item.setTextAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
            self.setItem(0, i, item)

    def width(self):
        width = 6
        if self.verticalHeader().isHidden() is False:
            width = self.verticalHeader().width() + 6

        for i in range(self.columnCount()):
            width = width + self.columnWidth(i)

        return width

    def height(self):
        height = 6
        if self.horizontalHeader().isHidden() is False:
            height = self.horizontalHeader().height() + 6
        for i in range(self.rowCount()):
            height = height + self.rowHeight(i)

        return height

    def do_optimal_size(self):
        size = QtCore.QSize(self.width(), self.height())
        self.setMaximumSize(size)
        self.setMinimumSize(size)

    def stretch_to_width(self, width_in):
        width = self.width()
        if width >= width_in:
            return

        factor = width_in/float(width)
        error = 0
        for i in range(self.length):
            current_cell_size = self.columnWidth(i)
            new_cell_size = int(current_cell_size * factor)
            error += new_cell_size - (current_cell_size * factor)
            if (error >= 1.0) or (error <= -1.0):
                new_cell_size -= int(error)
                error -= int(error)
            self.horizontalHeader().resizeSection(i, new_cell_size)

        self.do_optimal_size()

    def set_item(self, row, col, value):
        item = QtGui.QTableWidgetItem(str(value))
        item.setTextAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
        width = self._get_table_item_width(QtGui.QTableWidgetItem(value))
        if width > self.columnWidth(col):
            self.horizontalHeader().resizeSection(col, width)
        self.setItem(row, col, item)

    def set_numbers(self, value):
        new_numbers = str(value)
        if len(new_numbers) == 0:
            raise ValueError("Cant create a table for a value of length 0.")
        if len(new_numbers) != len(self.numbers):
            raise ValueError("New Values for table don't match size."
                             "Expected size %i but got %i" % (len(self.numbers), len(new_numbers)))
        self.numbers = new_numbers
        for i in range(len(self.numbers)):
            item = self.item(0, i)
            item.setText(self.numbers[i])

    def set_label(self, start, end, label, color=None):
        if (start < 0) or (end > self.columnCount()-1) or (start > end):
            raise ValueError("Invalid Start and End positions for Label: %s" % label)
        if self.rowCount() < 2:
            self.insertRow(1)
            for i in range(self.length):
                self.setItem(1, i, QtGui.QTableWidgetItem(''))

        span = (end-start)+1
        if span > 1:
            self.setSpan(1, start, 1, span)
        item = QtGui.QTableWidgetItem(label)
        item.setTextAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
        if color:
            item.setBackground(color)
        self.setItem(1, start, item)

        # Check if the label is larger then then cells it spans and resize the cells
        # accordingly, if the label ends up larger then the cells.
        label_width = self._get_table_item_width(QtGui.QTableWidgetItem(label))
        cells_width = 0
        for i in range(start, end+1):
            cells_width = cells_width + self.columnWidth(i)

        if label_width > cells_width:
            new_cell_size = label_width/span
            for i in range(start, end+1):
                self.horizontalHeader().resizeSection(i, new_cell_size)

        self.do_optimal_size()

    def grey_out_column(self, column):
        if (column < 0) or (column > self.length):
            raise ValueError("Supplied column is out of range for this table")
        for i in range(self.rowCount()):
            self.item(i, column).setForeground(QtGui.QColor(120, 120, 120))
            self.item(i, column).setBackground(QtGui.QColor(200, 200, 200))

    def undo_grey_out_column(self, column):
        if (column < 0) or (column > self.length):
            raise ValueError("Supplied column is out of range for this table")
        for i in range(self.rowCount()):
            self.item(i, column).setForeground(QtGui.QColor(0, 0, 0))
            self.item(i, column).setBackground(QtGui.QColor(255, 255, 255))

    # Create a table just to insert our item and show how large its width ends up...
    # We have to use this stupid workaround since QTableWidgetItem has no width() property...
    def _get_table_item_width(self, item):
        table = QtGui.QTableWidget()
        table.horizontalHeader().setResizeMode(QtGui.QHeaderView.ResizeToContents)
        table.setRowCount(1)
        table.setColumnCount(1)
        table.setItem(0, 0, item)
        width = table.columnWidth(0)
        table.deleteLater()
        return width


class BitsEditTable(BitsDisplayTable):

    def __init__(self, value, parent=None, optimalSize=True):
        BitsDisplayTable.__init__(self, value, parent, optimalSize)
        self.checkboxes = []
        self.populate_checkboxes()
        self.verticalHeader().setDefaultSectionSize(35)
        self.do_optimal_size()

    def populate_checkboxes(self):
        for i in range(self.length):
            widget = QtGui.QWidget()
            self.checkboxes += [QtGui.QCheckBox()]
            layout = QtGui.QHBoxLayout(widget)
            layout.addWidget(self.checkboxes[i])
            layout.setAlignment(QtCore.Qt.AlignCenter)
            layout.setContentsMargins(0, 0, 0, 0)
            widget.setLayout(layout)
            self.setCellWidget(0, i, widget)

    def set_numbers(self, value):
            new_numbers = str(value)
            if len(new_numbers) == 0:
                raise ValueError("Cant create a table for a value of length 0.")
            if len(new_numbers) != len(self.numbers):
                raise ValueError("New Values for table dont match size."
                                 "Expected size %i but got %i" % (len(self.numbers), len(new_numbers)))
            self.numbers = new_numbers
            for i in range(len(self.numbers)):
                if self.numbers[i] == '1':
                    self.checkboxes[i].setChecked(True)
                else:
                    self.checkboxes[i].setChecked(False)

    def get_bits(self):
        bits = ''
        for i in range(self.length):
            if self.checkboxes[i].isChecked():
                bits += '1'
            else:
                bits += '0'
        return bits

    def get_bit(self, bit):
        if bit > self.length:
            return None
        return self.checkboxes[(self.length - bit) - 1].isChecked()

    def clear_all_bits(self):
        for i in range(self.length):
            self.checkboxes[i].setChecked(False)


class AdvancedBoardInterface(QtGui.QWidget):

    def __init__(self, parent=None, board_id=None):
        QtGui.QWidget.__init__(self, parent)
        self.parent = parent
        self.do_layout()
        self.data_flow_pipeline_status = None
        # self.do_status_update() # Do not update status at init - gets updated whenever page is "opened"
        if board_id is None:
            print "No Valid board id specified for AdvancedBoardInterface."
            raise ValueError("No Valid board id specified for AdvancedBoardInterface.")
        self.board_id = board_id

    def do_layout(self):

        self.table_grid = QtGui.QGridLayout()
        self.setLayout(self.table_grid)

        self.table_grid.addWidget(QtGui.QLabel("Status1 Register 0x9050 (Readonly)"), 0, 0)
        self.t1 = QtGui.QScrollArea()
        self.table_grid.addWidget(self.t1, 1, 0)
        self.status1_table = BitsDisplayTable(32*'0', self)
        self.do_status1_table_layout(self.status1_table)
        # self.table_grid.addWidget(self.status1_table, 1, 0)
        self.t1.setWidget(self.status1_table)
        self.t1.setFixedHeight(self.status1_table.height()+24)

        self.table_grid.addWidget(QtGui.QLabel("Status2 Register 0x9054 (Readonly)"), 2, 0)
        self.t2 = QtGui.QScrollArea()
        self.table_grid.addWidget(self.t2, 3, 0)
        self.status2_table = BitsDisplayTable(32*'0', self)
        self.do_status2_table_layout(self.status2_table)
        # self.table_grid.addWidget(self.status2_table, 3, 0)
        self.t2.setWidget(self.status2_table)
        self.t2.setFixedHeight(self.status2_table.height()+24)

        self.table_grid.addWidget(QtGui.QLabel("Status3 Register 0x9058 (Readonly)"), 4, 0)
        self.t3 = QtGui.QScrollArea()
        self.table_grid.addWidget(self.t3, 5, 0)
        self.status3_table = BitsDisplayTable(32*'0', self)
        self.do_status3_table_layout(self.status3_table)
        # self.table_grid.addWidget(self.status3_table, 5, 0)
        self.t3.setWidget(self.status3_table)
        self.t3.setFixedHeight(self.status3_table.height()+24)

        # self.table_grid.addItem(QtGui.QSpacerItem(1, 20), 6, 0)
        self.table_grid.addWidget(QtGui.QLabel("Control Register 0x9040"), 7, 0)

        buttons_box = QtGui.QHBoxLayout()
        buttons_box.setAlignment(QtCore.Qt.AlignLeft)
        self.write_control_button = QtGui.QPushButton("Write Values to board")
        self.write_control_button.setMaximumWidth(200)
        buttons_box.addWidget(self.write_control_button)
        self.clear_control_button = QtGui.QPushButton("Clear Input")
        self.clear_control_button.setMaximumWidth(200)
        buttons_box.addWidget(self.clear_control_button)
        self.check_status_control_button = QtGui.QPushButton("Check Status")
        self.check_status_control_button.setMaximumWidth(200)
        buttons_box.addWidget(self.check_status_control_button)
        buttons_widget = QtGui.QWidget()
        buttons_widget.setLayout(buttons_box)
        self.table_grid.addWidget(buttons_widget, 8, 0)

        self.tedit = QtGui.QScrollArea()
        self.table_grid.addWidget(self.tedit, 9, 0)
        self.control_table = BitsEditTable(32*'0', self)
        self.do_control_table_layout(self.control_table)
        self.tedit.setWidget(self.control_table)
        self.tedit.setFixedHeight(self.control_table.height()+24)
        # self.table_grid.addWidget(self.control_table, 9, 0)

        self.write_control_button.clicked.connect(self.send_control_to_board)
        self.clear_control_button.clicked.connect(self.control_table.clear_all_bits)
        self.check_status_control_button.clicked.connect(self.do_status_update)
        self.check_status_control_button.setShortcut("F5")

        width1 = self.status1_table.width()
        width2 = self.status2_table.width()
        width3 = self.status3_table.width()
        width4 = self.control_table.width()
        max_width = max(width1, max(width2, max(width3, width4)))
        self.status1_table.stretch_to_width(max_width)
        self.status2_table.stretch_to_width(max_width)
        self.status3_table.stretch_to_width(max_width)
        self.control_table.stretch_to_width(max_width)


    def send_control_to_board(self):
        if bif._bif_continuous_read_is_enabled(self.board_id, tr("Heading", "Write Registers")):
            logging.log("Cant write to board while continuous readout is active")
            return

        bits = self.control_table.get_bits()
        # print bits
        dec_val_bits = int(bits, 2)
        # print dec_val_bits
        # self.parent.text_area.write("Writing to board Register 0x9040: %s" % ('0x{0:08x}'.format(dec_val_bits)))
        logging.info("Writing to board Register 0x9040: %s" % ('0x{0:08x}'.format(dec_val_bits)))
        try:
            board.write_pci(self.board_id, hex(dec_val_bits), '0x9040')
        except board.BoardError as e:
            QtGui.QMessageBox.critical(self, "Board communication",
                                       "Was unable to write value to board!\nReason: "+str(e)+"\nBoard: "+str(self.board_id))

        # self.parent.do_status_readout()
        self.do_status_update()

    def do_status1_table_layout(self, table):
        # from right to left
        table.set_label(29, 31, "FSM_Data_Pipeline_Status", QtCore.Qt.green)
        table.grey_out_column(28)
        table.set_label(27, 27, "FULL", QtCore.Qt.green)
        table.set_label(26, 26, "EMPTY", QtCore.Qt.green)
        table.grey_out_column(25)
        table.grey_out_column(24)
        table.set_label(14, 23, "RD_data_Counts", QtCore.Qt.green)
        table.set_label(13, 13, "OVR_ADC", QtGui.QColor(210, 210, 0))
        table.grey_out_column(12)
        table.grey_out_column(11)
        table.grey_out_column(10)
        table.grey_out_column(9)
        table.grey_out_column(8)
        table.set_label(7, 7, "PLL_LD", QtGui.QColor(210, 210, 0))
        table.grey_out_column(6)
        table.set_label(2, 5, "Master Control", QtCore.Qt.green)
        table.grey_out_column(1)
        table.set_label(0, 0, "1")

    def do_status2_table_layout(self, table):
        #from right to left
        table.set_label(31, 31, "FIFO 128 255 empty", QtCore.Qt.green)
        table.set_label(30, 30, "FIFO 128 255 full", QtCore.Qt.green)
        table.grey_out_column(29)
        table.grey_out_column(28)
        table.set_label(17, 27, "wr data count 128 255", QtGui.QColor(210, 210, 0))
        table.grey_out_column(16)
        table.set_label(15, 15, "FIFO 255 64 empty", QtCore.Qt.green)
        table.set_label(14, 14, "FIFO 255 64 full", QtCore.Qt.green)
        table.grey_out_column(13)
        table.grey_out_column(12)
        table.set_label(2, 11, "rd data count 255 64", QtGui.QColor(210, 210, 0))
        table.grey_out_column(1)
        table.grey_out_column(0)

    def do_status3_table_layout(self, table):
        #from right to left
        table.set_label(29, 31, "FSM_ARBITER_DDR3", QtCore.Qt.green)
        table.grey_out_column(28)
        table.set_label(25, 27, "FSM_WR_DDR3", QtCore.Qt.green)
        table.grey_out_column(24)
        table.set_label(21, 23, "FSM_R_DDR3", QtCore.Qt.green)
        table.grey_out_column(20)
        table.set_label(16, 19, "BC_ERROR", QtGui.QColor(210, 210, 0))
        table.set_label(1, 15, "Number of wrong BC", QtGui.QColor(255, 255, 0))
        table.grey_out_column(0)

    def do_control_table_layout(self, table):
        #from right to left
        table.set_label(31, 31, "reset", QtGui.QColor(0, 255, 255))
        table.grey_out_column(30)
        table.grey_out_column(29)
        table.grey_out_column(28)
        table.set_label(27, 27, "ADC_1(A+D)", QtGui.QColor(0, 255, 255))
        table.set_label(26, 26, "ADC_2(A+D)2", QtGui.QColor(0, 255, 255))
        table.set_label(25, 25, "T/H_1", QtGui.QColor(210, 210, 0))
        table.set_label(24, 24, "T/H_2", QtGui.QColor(210, 210, 0))
        table.set_label(23, 23, "T/H_3", QtGui.QColor(210, 210, 0))
        table.set_label(22, 22, "T/H_4", QtGui.QColor(210, 210, 0))
        table.set_label(21, 21, "EN_data_Trans", QtCore.Qt.yellow)
        table.set_label(20, 20, "EN_readout", QtCore.Qt.yellow)
        table.set_label(18, 19, "ADC_1", QtCore.Qt.yellow)
        table.set_label(16, 17, "ADC_2", QtCore.Qt.yellow)
        table.set_label(14, 15, "ADC_3", QtCore.Qt.yellow)
        table.set_label(12, 13, "ADC_4", QtCore.Qt.yellow)
        table.grey_out_column(11)
        table.grey_out_column(10)
        table.grey_out_column(9)
        table.grey_out_column(8)
        table.grey_out_column(7)
        table.grey_out_column(6)
        table.grey_out_column(5)
        table.grey_out_column(4)
        table.set_label(3, 3, "Header", QtCore.Qt.green)
        table.grey_out_column(2)
        table.set_label(1, 1, "Pilot Bunch by FPGA", QtGui.QColor(0, 255, 255))
        table.set_label(0, 0, "FPGA Temp monitor Reset", QtGui.QColor(0, 255, 255))

    def update_status(self, registers):
        try:
            self.status1_table.set_numbers('{0:032b}'.format(registers[0]))
            self.status2_table.set_numbers('{0:032b}'.format(registers[1]))
            self.status3_table.set_numbers('{0:032b}'.format(registers[2]))
        except Exception:
            return

    def do_status_update(self):
        if board.get_board_status(self.board_id).board_connected:
            registers = board.pci.read(self.board_id, 3, '0x9050', decimal=True)
            # TODO: KEEPING read_pci as this entire thing will be removed hopefully
            self.update_status(registers)
            control = board.pci.read(self.board_id, 1, '0x9040')[0]
            control_bits = '{0:032b}'.format(int(control, 16))
            self.control_table.set_numbers(control_bits)


class AdvanceControlView(kcgw.KCGWidgets):
    def __init__(self):
        super(AdvanceControlView, self).__init__()
        self.layout = QtGui.QHBoxLayout()
        self.setLayout(self.layout)
        self.tabs = QtGui.QTabWidget()
        self.layout.addWidget(self.tabs)

        self.tables = []

        for bid in available_boards:
            self.tables.append(AdvancedBoardInterface(board_id=bid))
            self.tabs.addTab(self.tables[-1], str(bid))

    def pages_update_function(self):
        for table in self.tables:
            table.do_status_update()