KaptureControlGui/KCG/widgets/FrequencyExtractWidget.py

from PyQt4 import QtCore, QtGui


from ..base import kcgwidget as kcgw
from ..base.globals import glob as global_objects
from ..base.backend import board
from ..base.backend.board import available_boards
from .. import config

import pyqtgraph as pg
from math import ceil
import numpy as np
import socket
import sys



from .PlotWidget import SubPlotWidget

__widget_id__ = None


class FrequencyExtractWidget(kcgw.KCGWidgets):
    def __init__(self, unique_id, parent):
        super(FrequencyExtractWidget, self).__init__()

        self.id = unique_id
        self.par = parent
        
        #ToDo: Maybe find valid data from the get-go?
        self.data = None


        self.board_config = board.get_board_config(available_boards[0]) 
        self.board_config.observe(self, self.dataSetChanged, 'lastDataSet')
        self.numADCs = self.board_config.get('adc_number')


        #Use a VBox. Top half should be the SubPlotWidget, bottom
        #half should be the controls
        self.layout = QtGui.QVBoxLayout()

        
        self.plotBox = QtGui.QVBoxLayout()
        self.plot = SubPlotWidget()

        self.region = pg.LinearRegionItem(values=[10,20])
        self.plot.plotItem.addItem(self.region)
        self.region.sigRegionChangeFinished.connect(self.doPlot)

        self.line = pg.InfiniteLine(angle=0, label='Y={value:0.2f}',
                                    labelOpts={'movable': True})
        self.plot.plotItem.addItem(self.line)
        self.line.hide()

        self.plotBox.addWidget(self.plot)


        #Controls for the plot
        self.controlsBox = QtGui.QHBoxLayout()

        self.adcSelect = QtGui.QComboBox(self)
        for i in range(self.numADCs):
            self.adcSelect.addItem("ADC {}".format(i+1))
        self.adcSelect.currentIndexChanged.connect(self.doPlot)


        self.bucketSelect = QtGui.QComboBox(self)
        self.bucketSelect.addItem("Mean")
        for i in range(184):
            self.bucketSelect.addItem("Bucket {}".format(i+1))
        self.bucketSelect.currentIndexChanged.connect(self.doPlot)


        self.fromBox = self.createSpinbox(0, 100000000, interval=100, connect=self.doPlot)
        self.toBox = self.createSpinbox(0, 100000000, start_value=1000, interval=100, connect=self.doPlot)

        self.controlsBox.addWidget(self.adcSelect)
        self.controlsBox.addWidget(self.bucketSelect)
        self.controlsBox.addStretch()
        self.controlsBox.addWidget(self.createLabel(text="From:"))
        self.controlsBox.addWidget(self.fromBox)
        self.controlsBox.addWidget(self.createLabel(text="To:"))
        self.controlsBox.addWidget(self.toBox)


        self.frequencyTools = QtGui.QHBoxLayout()
        
        self.freqText = QtGui.QLineEdit(self)
        self.isFreqValid = False

        self.frequencyTools.addWidget(self.createLabel(text="Frequency:"))
        self.frequencyTools.addWidget(self.freqText)


        self.ethernetControls = QtGui.QHBoxLayout()

        self.ethernetControls.addWidget(self.createLabel("IP:"))
        self.ip = QtGui.QLineEdit(self)
        self.ethernetControls.addWidget(self.ip)
        self.ethernetControls.addWidget(self.createLabel("Port:"))
        self.port = self.createSpinbox(1024, 65535)
        self.port.setValue(56000)
        self.ethernetControls.addWidget(self.port)
        self.ethButton = self.createButton("Connect", connect=self.connectButtonClicked)
        self.ethernetControls.addWidget(self.ethButton)

        self.socketConnected = False


        #7-Bit encoding values
        self.encodingControls = QtGui.QHBoxLayout()

        self.encodeBase = self.createSpinbox(0, 10000, interval=1, connect=self.updateRange)
        self.encodingControls.addWidget(self.createLabel("Encoding Offset:"))
        self.encodingControls.addWidget(self.encodeBase)
        self.encodeStep = QtGui.QDoubleSpinBox()
        self.encodeStep.setDecimals(2)
        self.encodeStep.setMaximum(1000.)
        self.encodeStep.setMinimum(0.)
        self.encodeStep.setSingleStep(0.01)
        self.encodeDivider = QtGui.QDoubleSpinBox()
        self.encodeDivider.setMinimum(0.)
        self.encodeDivider.setMaximum(100.)
        self.encodeDivider.setDecimals(2)
        self.encodeDivider.setSingleStep(1.)


        self.encodeStep.valueChanged.connect(self.updateRange)
        self.encodingControls.addWidget(self.createLabel("Encoding Step:"))
        self.encodingControls.addWidget(self.encodeStep)
        self.encodingRange = self.createLabel("NaN")
        self.encodingControls.addWidget(self.createLabel("Valid Range:"))
        self.encodingControls.addWidget(self.encodingRange)
        self.encodingControls.addWidget(self.createLabel("Value Divider:"))
        self.encodingControls.addWidget(self.encodeDivider)

        self.encodeBase.setValue(10)
        self.encodeStep.setValue(0.08)
        self.encodeDivider.setValue(1.)


        self.layout.addLayout(self.plotBox)
        self.layout.addLayout(self.controlsBox)
        self.layout.addLayout(self.frequencyTools)
        self.layout.addLayout(self.ethernetControls)
        self.layout.addWidget(self.createLabel("7-Bit Encoding controls (kHz):"))
        self.layout.addLayout(self.encodingControls)
        self.setLayout(self.layout)
        self.setWindowTitle("Frequency Extract")


    def connectButtonClicked(self):
        if not self.socketConnected:
            self.connectEthernet()
        else:
            self.disconnectEthernet()


    def connectEthernet(self):
        if self.socketConnected:
            return

        #closing a socket also frees the underlying File-Descriptor,
        #so we need to create a new socket every time we want to create
        #a new connection
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        ip = str(self.ip.text())
        try:
            socket.inet_aton(ip)
        except OSError:
            print("Malformed IP: %s"%ip)
            return

        try:
            self.socket.connect((self.ip.text(), self.port.value()))
            self.socketConnected = True
            self.ethButton.setText("Disconnect")
        except:
            print("Failed to connect to %s"%ip)
            self.socket = None


    def closeSocket(self):
        try:
            self.socket.close()
        except:
            pass

        self.socketConnected = False
        self.ethButton.setText("Connect")


    def disconnectEthernet(self):
        if not self.socketConnected:
            return

        #We tell the other end that we want to close the connection
        #by sending 0xFF. Our values are usually 7-Bit encoded, meaning
        #0xFF is an "Invalid" value and can be used for signalling
        self.sendValue(0xFF)
        self.closeSocket()



    def sendValue(self, value):
        if not self.socketConnected:
            return

        #socket.sendall() has two different behaviours, based on the Python
        #version.
        #In Python2, socket.sendall() will only accept a string
        #But in Python3, socket.sendall() will only accept a byte-sequence


        toSend = None
        if sys.version_info[0] == 2:
            toSend = chr(value)
        else:
            #bytes converts an array of integers into their shortest possible
            #bytewise representation.
            toSend = bytes([value])
         
        try:
            self.socket.sendall(toSend)
        except:
            print("Failed to send... closing down connection")
            self.closeSocket()


    def sendFreqEth(self, freq):
        if not self.socketConnected:
            return

        #We work in the kHz domain
        freq /= 1000

        offset = self.encodeBase.value()
        step = self.encodeStep.value()
        max = (offset + (step * 127))
        
        if (freq > max) or (freq < offset):
            print("Frequency outside range: %.2fkhZ - %.2fkHz! Won't send..."%(offset,max))
            return

        tmp = freq - offset - step
        count = 0
        while tmp > 0:
           tmp -= step
           count += 1

        self.sendValue(count)


    def updateRange(self):
        rangeMin = self.encodeBase.value()
        rangeMax = rangeMin + (self.encodeStep.value() * 127)
        self.encodingRange.setText("%.2f - %.2f (kHz)"%(rangeMin, rangeMax))


    def dataSetChanged(self, data=None):
        self.data = data
        self.doPlot()


    def doPlot(self):

        if not self.data:
            return

        #PlotWidget's "plot" function expects the fft_mode to have two entries
        #which we don't need here. So we need to shift our index by +2 in order
        #to accomodate for the two missing options in the bucket_select ComboBox
        fft_mode = self.bucketSelect.currentIndex() + 2
        adc = self.adcSelect.currentIndex()


        self.fftData = self.data.fft(adc=self.adcSelect.currentIndex(),
                                     frm=self.fromBox.value(),
                                     to=self.toBox.value(),
                                     drop_first_bin=True,
                                     nobunching=False)
        self.plot.plot(
                self.fftData,
                autorange=False,
                xvalueborders=[self.data.fftFreqDist(), self.data.fftMaxFreq()],
                fft_mode=fft_mode,
                log=False)

        self.plot.plotItem.setLabel('left', 'Spectral Intensity')

        #I am cheating a little bit and getting the readily processed data
        #from the plotItems, so I don't have to process, convert, format, etc.
        #the fftData again. We already did that in the SubPlotWidget.plot
        #function, so no need to do it again. Just steal the data from the
        #plotItems!
        self.fftYValues = self.plot.plotItemPlot[0].yData
        self.fftXValues = self.plot.plotItemPlot[0].xData

        region = self.region.getRegion()
   
        #Clip to valid data ranges
        rLeft = ceil(region[0]) if region[0] >=0 else 0
        rRight = ceil(region[1]) if region[1] < len(self.fftYValues) else len(self.fftYValues)


        #Python2 wants this to be specifically cast to integers
        rLeft = int(rLeft)
        rRight = int(rRight)

        #Make sure the region is within the boundaries of our data array
        if rLeft >= len(self.fftYValues) or rRight < 0:
            self.freqText.setText("Region boundaries out of data range")
            self.line.hide()
            self.isFreqValid = False
            return

        #If the region is not really a region, ignore it
        if rLeft == rRight:
            self.freqText.setText("Region too small")
            self.line.hide()
            self.isFreqValid = False
            return
    
        chunk = self.fftYValues[rLeft:rRight]
        maxVal = np.max(chunk)
        maxIndexInChunk = np.where(chunk == maxVal)

        self.line.setValue(maxVal)
        self.line.show()

        
        #np.where returns a tuple of indices (because it supports
        #multidimensional arrays). But since we know that our array is only
        #1-Dimensional, we can simply pick only the first dimension
        maxIndexInChunk = maxIndexInChunk[0]
        indexInData = rLeft + maxIndexInChunk

        #We are basically just repeating what the plot item also did to
        #determine the X-Axis labeling, and use it to calculate the X-Value
        #at the index we have identified
        xAxisScale = (self.data.fftMaxFreq() - self.data.fftFreqDist()) / float(self.fftYValues.shape[0])

        freq = self.fftXValues[indexInData][0]*xAxisScale
        freq = freq / self.encodeDivider.value()

        self.freqText.setText(str(freq))
        self.isFreqValid = True
        self.sendFreqEth(freq)



    def closeEvent(self, event):
        global __widget_id__
        __widget_id__ = None
        del self.par.widgets[self.id]

        self.board_config.unobserve(self, 'lastDataSet')

        #Tell the receiving end that we want to terminate the connection.
        self.sendValue(0xFF)


def addFrequencyExtractWidget():
    global __widget_id__
    if __widget_id__:
        global_objects.get_global('area').widgets[__widget_id__].setFocus()
    else:
        nid = kcgw.idg.genid()
        __widget_id__ = nid
        w = FrequencyExtractWidget(nid, global_objects.get_global('area'))
        global_objects.get_global('area').newWidget(w, "Frequency Extract", nid, widget_type=4)

kcgw.register_widget(QtGui.QIcon(config.icon_path("bbb.png")), "Frequency Extract", addFrequencyExtractWidget, "Ctrl+e")