meter.c

Go to the documentation of this file.

#include "meter.h"

char* channel_units[NUM_CHANNELS] = {"mA", "uA", "V", "V",
                                     "mA", "uA", "V", "V"};
uint32_t channel_scales[NUM_CHANNELS] = {1000000, 100000, 100000000, 100000000,
                                         1000000, 100000, 100000000, 100000000};
const uint32_t digital_input_bits[NUM_DIGITAL_INPUTS] = {
    DIGIN1_BIT, DIGIN2_BIT, DIGIN3_BIT, DIGIN4_BIT, DIGIN5_BIT, DIGIN6_BIT};

void meter_init(void) {
    // init ncurses mode
    initscr();
    // hide cursor
    curs_set(0);

    mvprintw(1, 1, "Starting RocketLogger Meter ...");
    refresh();
}

void meter_stop(void) { endwin(); }

void meter_print_buffer(struct rl_conf* conf, void* buffer_addr,
                        uint32_t sample_size) {

    // clear screen
    erase();

    // counter variables
    uint32_t j = 0;
    uint32_t k = 0;
    uint32_t l = 0;
    uint32_t i = 0; // currents
    uint32_t v = 0; // voltages

    uint32_t num_channels = count_channels(conf->channels);

    // data
    int64_t value = 0;
    int32_t dig_data[2];
    int32_t channel_data[num_channels];

    // number of samples to average
    uint32_t avg_number = conf->sample_rate / conf->update_rate;

    // read digital channels
    dig_data[0] = (int32_t)(*((int8_t*)(buffer_addr)));
    dig_data[1] = (int32_t)(*((int8_t*)(buffer_addr + 1)));
    buffer_addr += PRU_DIG_SIZE;

    // read, average and scale values (if channel selected)
    for (j = 0; j < NUM_CHANNELS; j++) {
        if (conf->channels[j] == CHANNEL_ENABLED) {
            value = 0;
            if (sample_size == 4) {
                for (l = 0; l < avg_number; l++) {
                    value += *((int32_t*)(buffer_addr + sample_size * j +
                                          l * (NUM_CHANNELS * sample_size +
                                               PRU_DIG_SIZE)));
                }
            } else {
                for (l = 0; l < avg_number; l++) {
                    value += *((int16_t*)(buffer_addr + sample_size * j +
                                          l * (NUM_CHANNELS * sample_size +
                                               PRU_DIG_SIZE)));
                }
            }
            value = value / (int64_t)avg_number;
            channel_data[k] =
                (int32_t)(((int32_t)value + calibration.offsets[j]) *
                          calibration.scales[j]);
            k++;
        }
    }

    // display values
    mvprintw(1, 28, "RocketLogger Meter");

    for (j = 0; j < NUM_CHANNELS; j++) {
        if (conf->channels[j] == CHANNEL_ENABLED) {
            if (is_current(j)) {
                // current
                mvprintw(i * 2 + 5, 10, "%s:", channel_names[j]);
                mvprintw(i * 2 + 5, 15, "%12.6f%s",
                         ((float)channel_data[v + i]) / channel_scales[j],
                         channel_units[j]);
                i++;
            } else {
                // voltage
                mvprintw(v * 2 + 5, 55, "%s:", channel_names[j]);
                mvprintw(v * 2 + 5, 60, "%9.6f%s",
                         ((float)channel_data[v + i]) / channel_scales[j],
                         channel_units[j]);
                v++;
            }
        }
    }

    // display titles, range information
    if (i > 0) { // currents
        mvprintw(3, 10, "Currents:");

        // display range information
        mvprintw(3, 33, "Low range:");
        if ((dig_data[0] & I1L_VALID_BIT) > 0) {
            mvprintw(5, 33, "I1L invalid");
        } else {
            mvprintw(5, 33, "I1L valid");
        }
        if ((dig_data[1] & I2L_VALID_BIT) > 0) {
            mvprintw(11, 33, "I2L invalid");
        } else {
            mvprintw(11, 33, "I2L valid");
        }
    }

    if (v > 0) { // voltages
        mvprintw(3, 55, "Voltages:");
    }

    // digital inputs
    if (conf->digital_inputs > 0) {
        mvprintw(20, 10, "Digital Inputs:");

        j = 0;
        for (; j < 3; j++) {
            mvprintw(20 + 2 * j, 30, "%s:", digital_input_names[j]);
            mvprintw(20 + 2 * j, 38, "%d",
                     (dig_data[0] & digital_input_bits[j]) > 0);
        }
        for (; j < 6; j++) {
            mvprintw(20 + 2 * (j - 3), 50, "%s:", digital_input_names[j]);
            mvprintw(20 + 2 * (j - 3), 58, "%d",
                     (dig_data[1] & digital_input_bits[j]) > 0);
        }
    }

    refresh();
}