RadiometerLiveView.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# vispy: gallery 2
# Copyright (c) Vispy Development Team. All Rights Reserved.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.

"""
Read the signal from the radiometer in real-time and show it on the screen.
"""

from __future__ import print_function, division, absolute_import

import os
import sys
import math

import numpy as np
import vispy
from vispy import gloo
from vispy import app

import ads1256
from GetRDMConfig import RDMConfig, readConfig


DEFAULT_PATH = "/home/pi/RadiometerData"
CONFIG = "config.txt"

# Number of cols and rows in the table.
nrows = 1
ncols = 1

# Number of signals.
m = nrows*ncols

##############################################################################################################
# Number of samples on screen.
n = 1000

channel = 0
sps = 3750
#gain = 1
#mode = 1

DATA_MIN = 0
DATA_MAX = 2**23 - 1
data_min=1
data_max=-1
height=0


# Config file path
config_path = os.path.join(DEFAULT_PATH,CONFIG)


# Check if the config file exists
if not os.path.isfile(config_path):
    print('The configuruation file does not exits: ', config_path)
    print('Run the RadiometerRun.py script to generate a config file and edit it using appropriate values.')
    sys.exit()

# Read the config file
rdm_config = readConfig(config_path)


# Init the ADC
ads1256.init(rdm_config.gain,sps, rdm_config.mode)
ads1256.init_channel(channel)

##############################################################################################################

# Generate the signals as a (m, n) array.
y = np.zeros((m, n)).astype(np.float32)
# Color of each vertex (TODO: make it more efficient by using a GLSL-based
# color map and the index).
color = np.repeat(np.random.uniform(size=(m, 3), low=.5, high=.9),
                  n, axis=0).astype(np.float32)

# Signal 2D index of each vertex (row and col) and x-index (sample index
# within each signal).
index = np.c_[np.repeat(np.repeat(np.arange(ncols), nrows), n),
              np.repeat(np.tile(np.arange(nrows), ncols), n),
              np.tile(np.arange(n), m)].astype(np.float32)

VERT_SHADER = """
#version 120

// y coordinate of the position.
attribute float a_position;

// row, col, and time index.
attribute vec3 a_index;
varying vec3 v_index;

// 2D scaling factor (zooming).
uniform vec2 u_scale;

// Size of the table.
uniform vec2 u_size;

// Number of samples per signal.
uniform float u_n;

// Color.
attribute vec3 a_color;
varying vec4 v_color;

// Varying variables used for clipping in the fragment shader.
varying vec2 v_position;
varying vec4 v_ab;

void main() {
    float nrows = u_size.x;
    float ncols = u_size.y;

    // Compute the x coordinate from the time index.
    float x = -1 + 2*a_index.z / (u_n-1);
    vec2 position = vec2(x - (1 - 1 / u_scale.x), a_position);

    // Find the affine transformation for the subplots.
    vec2 a = vec2(1./ncols, 1./nrows)*.99;
    vec2 b = vec2(-1 + 2*(a_index.x+.5) / ncols,
                  -1 + 2*(a_index.y+.5) / nrows);
    // Apply the static subplot transformation + scaling.
    gl_Position = vec4(a*u_scale*position+b, 0.0, 1.0);

    v_color = vec4(a_color, 1.);
    v_index = a_index;

    // For clipping test in the fragment shader.
    v_position = gl_Position.xy;
    v_ab = vec4(a, b);
}
"""

FRAG_SHADER = """
#version 120

varying vec4 v_color;
varying vec3 v_index;

varying vec2 v_position;
varying vec4 v_ab;

void main() {
    gl_FragColor = v_color;

    // Discard the fragments between the signals (emulate glMultiDrawArrays).
    if ((fract(v_index.x) > 0.) || (fract(v_index.y) > 0.))
        discard;

    // Clipping test.
    vec2 test = abs((v_position.xy-v_ab.zw)/v_ab.xy);
    if ((test.x > 1) || (test.y > 1))
        discard;
}
"""


class Canvas(app.Canvas):
    def __init__(self):
        app.Canvas.__init__(self, keys='interactive')
        self.program = gloo.Program(VERT_SHADER, FRAG_SHADER)
        self.program['a_position'] = y.reshape(-1, 1)
        self.program['a_color'] = color
        self.program['a_index'] = index
        self.program['u_scale'] = (1.0, 1.0)
        self.program['u_size'] = (nrows, ncols)
        self.program['u_n'] = n

        gloo.set_viewport(0, 0, *self.physical_size)

        self._timer = app.Timer('auto', connect=self.on_timer, start=True)

        gloo.set_state(clear_color='black', blend=True,
                       blend_func=('src_alpha', 'one_minus_src_alpha'))
        
        self.title = 'Radiometer live'
        
        self.hold_plot = False
        
        self.autoscale = False
        self.afirstpress = False
        
        self.show()

    def on_resize(self, event):
        gloo.set_viewport(0, 0, *event.physical_size)

    def on_mouse_wheel(self, event):
        dx = np.sign(event.delta[1]) * .05
        scale_x, scale_y = self.program['u_scale']
        scale_x_new, scale_y_new = (scale_x * math.exp(2.5*dx),
                                    scale_y * math.exp(0.0*dx))
        self.program['u_scale'] = (max(1, scale_x_new), max(1, scale_y_new))
        self.update()
        
    def on_key_press(self, event):
        # modifiers = [key.name for key in event.modifiers]
        
        # Hold the plot if Space is pressed    
        if event.key.name == 'Space':
            self.hold_plot = not self.hold_plot
            
            if self.hold_plot:
                print('Paused!')
                
            else:
                print('Unpaused!')
        
        if event.key.name == 'A':
            self.autoscale = not self.autoscale
            
            if self.autoscale:
                print('Autoscale enabled!')
                scale_x, scale_y = self.program['u_scale']
                
                if((np.amax(y)-np.amin(y))>0.005):
                    self.program['a_position'] = y - (np.amax(y) + np.amin(y))/2.0
                    scale_x_new, scale_y_new = (scale_x,(2.0/(np.amax(y)-np.amin(y))))
                    self.program['u_scale'] = (max(1, scale_x_new), max(1, scale_y_new))
                    self.update()
                else:
                    pass
                
            else:
                print('Autoscale Disabled!')
                scale_x, scale_y = self.program['u_scale']
                scale_x_new, scale_y_new = (scale_x,1)
                self.program['u_scale'] = (max(1, scale_x_new), max(1, scale_y_new))
                self.update()
        # print('Key pressed - text: %r, key: %s, modifiers: %r' % (
        #     event.text, event.key.name, modifiers))

    def on_key_release(self, event):
        pass
        

    def on_timer(self, event):
        """Add some data at the end of each signal (real-time signals)."""
        k = 1
            
        y[:, :-k] = y[:, k:]
        data_chunk = ads1256.read_channel(channel)
        print(data_chunk)
        # Scale data to -1 to 1 range
        data_chunk = data_chunk/(DATA_MAX/2.0) - 1
        
        data_min = np.amin(y)
        data_max = np.amax(y)
        
        y[:, -k:] = data_chunk
        
        if self.autoscale and (not self.hold_plot) and ((data_max - data_min)>0.005):
            
            self.program['a_position'] = y - (data_max + data_min)/2.0
            
            scale_x, scale_y = self.program['u_scale']
            scale_x_new, scale_y_new = (scale_x,(2.0/(np.amax(y)-np.amin(y))))
            self.program['u_scale'] = (max(1, scale_x_new), max(1, scale_y_new))
            
            self.update()
        elif (not self.hold_plot or ((data_max - data_min)<0.005)):
            scale_x, scale_y = self.program['u_scale']
            scale_x_new, scale_y_new = (scale_x,1)
            self.program['u_scale'] = (max(1, scale_x_new), max(1, scale_y_new))
            
            self.program['a_position'].set_data(y.ravel().astype(np.float32))
            self.update()

    def on_draw(self, event):
        gloo.clear()
        self.program.draw('line_strip')

if __name__ == '__main__':
    c = Canvas()
    #c.measure_fps()
    app.run()