Example #1
0
    def set_data(self, evt):
        dB = evt.data
        num_curves = evt.ninputs
        L = len(dB) / num_curves

        self._points = []
        for i in range(0, num_curves):
            self._points.append(numpy.zeros((L, 2), numpy.float64))
        for i in range(0, num_curves):
            self._points[i][:, 0] = self.curvesink.x_vals
            self._points[i][:, 1] = dB[i * L:(i * L) + L]

        lines = []
        for i in range(0, num_curves):
            lines.append(
                plot.PolyLine(self._points[i],
                              colour=COLOR_LIST[i % num_curves],
                              legend=self.curvesink.legends[i]))

        graphics = plot.PlotGraphics(lines,
                                     title=self.curvesink.title,
                                     xLabel=self.x_units,
                                     yLabel=self.y_units)
        x_range = self.curvesink.x_vals[0], self.curvesink.x_vals[-1]
        ymax = self.curvesink.ref_level
        ymin = self.curvesink.ref_level - self.curvesink.y_per_div * self.curvesink.y_divs
        y_range = ymin, ymax
        self.plot.Draw(graphics,
                       xAxis=x_range,
                       yAxis=y_range,
                       step=self.curvesink.y_per_div)
    def format_xy_data(self, evt):
        info = self.info
        records = evt.data
        nchannels = len(records)
        npoints = len(records[0])

        if nchannels < 2:
            return

        objects = []
        # points = zip(records[0], records[1])
        points = numpy.zeros((len(records[0]), 2), numpy.float32)
        points[:, 0] = records[0]
        points[:, 1] = records[1]

        self.SetXUseScopeTicks(False)

        m = info.get_marker()
        if m == 'line':
            objects.append(plot.PolyLine(points, colour=self.channel_color(0)))
        else:
            objects.append(
                plot.PolyMarker(points, marker=m,
                                colour=self.channel_color(0)))

        graphics = plot.PlotGraphics(objects,
                                     title=self.info.title,
                                     xLabel='I',
                                     yLabel='Q')

        self.Draw(graphics, xAxis=self.x_range, yAxis=self.y_range)
        self.update_y_range()
        self.update_x_range()
Example #3
0
    def set_data(self, evt):
        dB = evt.data
        L = len(dB)

        if self.peak_hold:
            if self.peak_vals is None:
                self.peak_vals = dB
            else:
                self.peak_vals = numpy.maximum(dB, self.peak_vals)
                dB = self.peak_vals

        x = max(abs(self.facsink.sample_rate), abs(self.facsink.baseband_freq))
        sf = 1000.0
        units = "ms"

        x_vals = ((numpy.arange(L / 2) * ((sf / self.facsink.sample_rate))))
        points = numpy.zeros((len(x_vals), 2), numpy.float64)
        points[:, 0] = x_vals
        points[:, 1] = dB[0:L / 2]

        lines = plot.PolyLine(points, colour='green')  # DARKRED

        graphics = plot.PlotGraphics([lines],
                                     title=self.facsink.title,
                                     xLabel=units,
                                     yLabel="dB")

        self.Draw(graphics, xAxis=None, yAxis=self.y_range)
        self.update_y_range()
Example #4
0
    def format_data (self, evt):
        if not self.info.running:
            return

        if self.info.xy:
            self.format_xy_data (evt)
            return

        info = self.info
        records = evt.data
        nchannels = len (records)
        npoints = len (records[0])

        objects = []

        Ts = 1.0 / (info.get_sample_rate () / info.get_decimation_rate ())
        x_vals = Ts * numpy.arange (-npoints/2, npoints/2)

        # preliminary clipping based on time axis here, instead of in graphics code
        time_per_window = self.info.get_time_per_div () * 10
        n = int (time_per_window / Ts + 0.5)
        n = n & ~0x1                    # make even
        n = max (2, min (n, npoints))

        self.SetXUseScopeTicks (True)   # use 10 divisions, no labels

        for ch in range(nchannels):
            r = records[ch]

            # plot middle n points of record

            lb = npoints/2 - n/2
            ub = npoints/2 + n/2
            # points = zip (x_vals[lb:ub], r[lb:ub])
            points = numpy.zeros ((ub-lb, 2), numpy.float64)
            points[:,0] = x_vals[lb:ub]
            points[:,1] = r[lb:ub]

            m = info.get_marker ()
            if m == 'line':
                objects.append (plot.PolyLine (points,
                                               colour=self.channel_color (ch),
                                               legend=('Ch%d' % (ch+1,))))
            else:
                objects.append (plot.PolyMarker (points,
                                                 marker=m,
                                                 colour=self.channel_color (ch),
                                                 legend=('Ch%d' % (ch+1,))))

        graphics = plot.PlotGraphics (objects,
                                      title=self.info.title,
                                      xLabel = '', yLabel = '')

        time_per_div = info.get_time_per_div ()
        x_range = (-5.0 * time_per_div, 5.0 * time_per_div) # ranges are tuples!
        volts_per_div = info.get_volts_per_div ()
        if not self.info.autorange:
            self.y_range = (-4.0 * volts_per_div, 4.0 * volts_per_div)
        self.Draw (graphics, xAxis=x_range, yAxis=self.y_range)
        self.update_y_range () # autorange to self.y_range
Example #5
0
    def format_data(self, evt):
        if not self.info.running:
            return

        info = self.info
        records = evt.data
        nchannels = len(records)
        npoints = len(records[0])
        self.total_points += npoints

        x_vals = numpy.arange(0, evt.samples_per_symbol)

        self.SetXUseScopeTicks(True)  # use 10 divisions, no labels

        objects = []
        colors = [
            'red', 'orange', 'yellow', 'green', 'blue', 'violet', 'cyan',
            'magenta', 'brown', 'black'
        ]

        r = records[0]  # input data
        v_min = None
        v_max = None
        for i in range(evt.num_plots):
            points = []
            for j in range(evt.samples_per_symbol):
                v = r[i * evt.samples_per_symbol + j]
                if (v_min is None) or (v < v_min):
                    v_min = v
                if (v_max is None) or (v > v_max):
                    v_max = v
                p = [j, v]
                points.append(p)
            objects.append(
                plot.PolyLine(points,
                              colour=colors[i % len(colors)],
                              legend=('')))

        graphics = plot.PlotGraphics(objects,
                                     title=self.info.title,
                                     xLabel='Time',
                                     yLabel='Amplitude')
        x_range = (0., 0. + (evt.samples_per_symbol - 1))  # ranges are tuples!
        if self.y_range is None:
            v_scale = max(abs(v_min), abs(v_max))
            y_range = (-v_scale, v_scale)
            #y_range = (min, max)
        else:
            y_range = self.y_range
        self.Draw(graphics, xAxis=x_range, yAxis=y_range)
Example #6
0
    def format_data(self, evt):
        if not self.info.running:
            return

        info = self.info
        records = evt.data
        nchannels = len(records)
        npoints = len(records[0])
        self.total_points += npoints

        x_vals = numpy.arange(0, self.samples_per_symbol)

        self.SetXUseScopeTicks(True)  # use 10 divisions, no labels

        objects = []
        colors = [
            'red', 'orange', 'yellow', 'green', 'blue', 'violet', 'cyan',
            'magenta', 'brown', 'black'
        ]

        r = records[0]  # input data
        for i in range(self.num_plots):
            points = []
            for j in range(self.samples_per_symbol):
                p = [j, r[i * self.samples_per_symbol + j]]
                points.append(p)
            objects.append(
                plot.PolyLine(points,
                              colour=colors[i % len(colors)],
                              legend=('')))

        graphics = plot.PlotGraphics(objects,
                                     title='Data Scope',
                                     xLabel='Time',
                                     yLabel='Amplitude')

        x_range = (0., 0. + (self.samples_per_symbol - 1)
                   )  # ranges are tuples!
        self.y_range = (-4., 4.)  # for standard -3/-1/+1/+3
        self.Draw(graphics, xAxis=x_range, yAxis=self.y_range)
Example #7
0
    def set_data (self, evt):
        calc_min = 99e10
        calc_max = -99e10
        dB = evt.data
        L = len (dB)

        calc_min = min(dB)
        calc_max = max(dB)

        if (self.ra_fftsink.ofunc != None):
            self.ra_fftsink.ofunc(evt.data,L)
        
        if self.peak_hold:
            if self.peak_vals is None:
                self.peak_vals = dB
            else:
                self.peak_vals = numpy.maximum(dB, self.peak_vals)
                dB = self.peak_vals

        x = max(abs(self.ra_fftsink.sample_rate), abs(self.ra_fftsink.baseband_freq))
        if x >= 1e9:
            sf = 1e-9
            units = "GHz"
        elif x >= 1e6:
            sf = 1e-6
            units = "MHz"
        elif x >= 1e3:
            sf = 1e-3
            units = "kHz"
        else:
            sf = 1.0
            units = "Hz"

        if self.ra_fftsink.input_is_real:     # only plot 1/2 the points
            x_vals = ((numpy.arange (L/2)
                       * (self.ra_fftsink.sample_rate * sf / L))
                      + self.ra_fftsink.baseband_freq * sf)
            points = numpy.zeros((len(x_vals), 2), numpy.float64)
            points[:,0] = x_vals
            points[:,1] = dB[0:L/2]
        else:
            # the "negative freqs" are in the second half of the array
            x_vals = ((numpy.arange(-L/2, L/2)
                       * (self.ra_fftsink.sample_rate * sf / L))
                      + self.ra_fftsink.baseband_freq * sf)
            points = numpy.zeros((len(x_vals), 2), numpy.float64)
            points[:,0] = x_vals
            points[:,1] = numpy.concatenate ((dB[L/2:], dB[0:L/2]))

        lines = plot.PolyLine (points, colour='BLUE')
        graphics = plot.PlotGraphics ([lines],
                                      title=self.ra_fftsink.title,
                                      xLabel = units, yLabel = "dB")

        self.Draw (graphics, xAxis=None, yAxis=self.y_range)
        d = calc_max - calc_min
        d = d * 0.1
        if self.ra_fftsink.autoscale == True:
            self.y_range = self._axisInterval ('min', calc_min-d, calc_max+d)
        else:
            self.update_y_range ()