ライブラリ完備！組立式ラズパイI/O増設ボード MCC DAQ HATSファミリ誕生

#include 
#include 
#include "daqhats_utils.h"  // daqhats\examples\c\daqhats_utils.h

int main()
{
    uint8_t     brd_addr;
    double      analog_val;
    

    // select the device to be used.
    if (select_hat_device(HAT_ID_MCC_152, &brd_addr) != 0) {
        return 1;
    }
    printf("MCC152 address %d\n", brd_addr);

    // open a connection to the device.
    if (mcc152_is_open(brd_addr) == 0) {
        if (mcc152_open(brd_addr) != RESULT_SUCCESS) {
            printf("open failure\n");
            return 1;
        }
    }

    analog_val  = 0.0;

    while (1) {
        double      output_buf;
        uint8_t     ch      = 0;
        uint32_t    options = OPTS_DEFAULT;

        // analog output (ch 0)
        if (mcc152_a_out_write(brd_addr, ch, options, analog_val) != RESULT_SUCCESS) {
            mcc152_close(brd_addr);
            return 1;
        }

        usleep(1000);       // 1/1000 sec

        analog_val  += 0.1;
        if (analog_val > 3.0) {
            analog_val  = 0.0;
        }
    }

    return 0;
}

NAME = sample
OBJ = $(NAME).o
LIBS = -ldaqhats -lm
CFLAGS = -O2 -Wall -I/usr/local/include -I./ -g
CC = gcc
EXTENSION = .c

all: $(NAME)

%.o: %$(EXTENSION) $(DEPS)
    $(CC) -c -o $@ $< $(CFLAGS)

$(NAME): $(OBJ)
    $(CC) -o $@ $^ $(CFLAGS) $(LIBS)

.PHONY: clean

clean:
    @rm -f *.o *~ core $(NAME)

#!/usr/bin/env python

from __future__ import print_function
from time import sleep
from daqhats import mcc152, OptionFlags, HatIDs, HatError
from daqhats_utils import select_hat_device

def main():
    brd_addr    = select_hat_device(HatIDs.MCC_152)
    hat         = mcc152(brd_addr)
    options     = OptionFlags.DEFAULT
    ch          = 0

    analog_val  = 0.0

    while True:
        hat.a_out_write(ch, analog_val, options)
        analog_val  = analog_val + 0.1
        if analog_val > 3.0:
            analog_val  = 0.0
        sleep(0.001)

if __name__ == '__main__':
    main()

#include 
#include 
#include "daqhats_utils.h"  // daqhats\examples\c\daqhats_utils.h

int main()
{
    uint8_t     brd_addr;   // board address

    // select the device to be used.
    if (select_hat_device(HAT_ID_MCC_118, &brd_addr) != 0) {
        return 1;
    }
    printf("MCC118 address = %d\n", brd_addr);

    // open a connection
    if (mcc118_is_open(brd_addr) == 0) {
        if (mcc118_open(brd_addr) != RESULT_SUCCESS) {
            printf("open failure\n");
            return 1;
        }
    }

    while (1) {
        double      input_buf;
        uint8_t     ch;
        uint32_t    options = OPTS_DEFAULT;

        // read all input channels
        for (ch = 0; ch < 8; ch++) {
            if (mcc118_a_in_read(brd_addr, ch, options, &input_buf) != RESULT_SUCCESS) {
                mcc152_close(brd_addr);
                return 1;
            }
            printf("CH%d = %fV ", ch, input_buf);
        }
        printf("\n\n");

        usleep(1000 * 1000);    // 1 sec
    }

    return 0;
}

#!/usr/bin/env python

from __future__ import print_function
from time import sleep
from sys import stdout
from daqhats import mcc118, OptionFlags, HatIDs, HatError
from daqhats_utils import select_hat_device, enum_mask_to_string

def main():
    brd_addr            = select_hat_device(HatIDs.MCC_118)
    hat                 = mcc118(brd_addr)
    options             = OptionFlags.DEFAULT

    while True:
        for ch in range(0, 7+1):
            input_buf = hat.a_in_read(ch, options)
            print('CH{}={:2.5}V  '.format(ch, input_buf), end='')
        print('\n')
        stdout.flush()
        sleep(1)

if __name__ == '__main__':
    main()

// add "-lpthread" to LIBS definition in makefile

#include 
#include 
#include 
#include "daqhats_utils.h"  // daqhats\examples\c\daqhats_utils.h

#define INTERVAL    5000        // usec

volatile bool   timer_flag  = false;

void timer_func(void)
{
    printf("start timer thread\n");
    while (1) {
        usleep(INTERVAL);
        timer_flag  = true;
    }
}


int main()
{
    uint8_t     brd_addr;
    double      analog_val[2];

    pthread_t   th;

    // select the device to be used.
    if (select_hat_device(HAT_ID_MCC_152, &brd_addr) != 0) {
        return 1;
    }
    printf("MCC152 address %d\n", brd_addr);

    // open a connection to the device.
    if (mcc152_is_open(brd_addr) == 0) {
        if (mcc152_open(brd_addr) != RESULT_SUCCESS) {
            printf("open failure\n");
            return 1;
        }
    }

    // start timer thread
    pthread_create(&th, NULL, (void *)timer_func, NULL);

    analog_val[0]  = 0.0;
    analog_val[1]  = 3.0;

    while (1) {
        uint32_t    options = OPTS_DEFAULT;

        // analog output (ch 0,1)
        if (mcc152_a_out_write_all(brd_addr, options, analog_val) != RESULT_SUCCESS) {
            mcc152_close(brd_addr);
            return 1;
        }

        if (analog_val[0] == 3.0) {
            analog_val[0]  = 0.0;
            analog_val[1]  = 3.0;
        }
        else {
            analog_val[0]  = 3.0;
            analog_val[1]  = 0.0;
        }

        while (timer_flag == false)
            ;
        timer_flag  = false;
    }

    return 0;
}

#include 
#include 
#include 
#include "daqhats_utils.h"

#include 

#define RATE_SPS    500.0

#define GPIO_PORT   21      // pin 40

void gpio_export(int pin)
{
    int     hd_gpio;
    char    wbuf[64];
    if ((hd_gpio = open("/sys/class/gpio/export", O_WRONLY)) < 0) {
        fprintf(stderr, "cannot open gpio_export (forget to sudo?)\n");
        return;
    }
    sprintf(wbuf, "%d", pin);
    write(hd_gpio, wbuf, strlen(wbuf));
    close(hd_gpio);
}

void gpio_setdir(int pin, int dir)
{
    int     hd_gpio;
    char    wbuf[64];
    sprintf(wbuf, "/sys/class/gpio/gpio%d/direction", pin);
    if ((hd_gpio = open(wbuf, O_WRONLY)) < 0) {
        fprintf(stderr, "cannot open %s (forget to sudo?)\n", wbuf);
        return;
    }
    if (dir == 0) {
        sprintf(wbuf, "out");
    }
    else {
        sprintf(wbuf, "in");
    }
    write(hd_gpio, wbuf, strlen(wbuf));
    close(hd_gpio);
}

void gpio_in(int pin, uint8_t *val)
{
    int     hd_gpio;
    char    wbuf[64];
    char    rbuf;
    sprintf(wbuf, "/sys/class/gpio/gpio%d/value", pin);
    if ((hd_gpio = open(wbuf, O_RDONLY)) < 0) {
        fprintf(stderr, "cannot open %s (forget to sudo?)\n", wbuf);
        return;
    }
    read(hd_gpio, &rbuf, 1);
    close(hd_gpio);
    if (rbuf == '1')
        *val    = 1;
    else
        *val    = 0;
}

int main()
{
    uint8_t     addr_152, addr_118;
    uint32_t    options     = OPTS_CONTINUOUS;
    double      analog_val[2];

    uint8_t     prev_trig   = 0;

    // select the device to be used.
    if (select_hat_device(HAT_ID_MCC_118, &addr_118) != 0) {
        return 1;
    }
    printf("MCC118 dev_addr %d\n", addr_118);

    if (select_hat_device(HAT_ID_MCC_152, &addr_152) != 0) {
        return 1;
    }
    printf("MCC152 dev_addr %d\n", addr_152);

    // open a connection to the device.
    if (mcc118_is_open(addr_118) == 0) {
        if (mcc118_open(addr_118) != RESULT_SUCCESS) {
            printf("unable to open device at dev_addr %d\n", addr_118);
            return 1;
        }
    }

    if (mcc152_is_open(addr_152) == 0) {
        if (mcc152_open(addr_152) != RESULT_SUCCESS) {
            printf("unable to open device at dev_addr %d\n", addr_152);
            return 1;
        }
    }

    // configure GPIO
    gpio_export(GPIO_PORT);
    gpio_setdir(GPIO_PORT, 1);      // input

    // generate trigger clock
    mcc118_a_in_scan_stop(addr_118);
    mcc118_a_in_scan_cleanup(addr_118);
    if (mcc118_a_in_scan_start(addr_118, CHAN7, 100 * 1000 * 1000 /* set large number as far as possible */, RATE_SPS, options) != RESULT_SUCCESS) {
        fprintf(stderr, "mcc118 scan_start() error\n");
        return -1;
    }

    // main loop
    while (1) {
        uint8_t trig;
        // check trigger
        gpio_in(GPIO_PORT, &trig);

        if (trig != prev_trig) {
            // analog output (ch 0, 1)
            if (mcc152_a_out_write_all(addr_152, options, analog_val) != RESULT_SUCCESS) {
                mcc152_close(addr_152);
                return 1;
            }

            if (analog_val[0] == 3.0) {
                analog_val[0]  = 0.0;
                analog_val[1]  = 3.0;
            }
            else {
                analog_val[0]  = 3.0;
                analog_val[1]  = 0.0;
            }
        }
        prev_trig   = trig;

        // read MC118 (to generate clk)
        uint16_t    read_status;
        double      rxbuf[10];
        uint32_t    read_num;
        mcc118_a_in_scan_read(addr_118, &read_status, -1, -1, rxbuf, 10, &read_num);
    }

    return 0;
}

#!/usr/bin/env python

from __future__ import print_function
from time import sleep
from sys import stdout
from daqhats import mcc118, OptionFlags, HatIDs, HatError
from daqhats_utils import select_hat_device, enum_mask_to_string

import matplotlib.pyplot as plt
import numpy as np

def main():
    brd_addr    = select_hat_device(HatIDs.MCC_118)
    hat         = mcc118(brd_addr)
    options     = OptionFlags.DEFAULT

# initialize data list
    ch0_list    = [0]
    ch1_list    = [0]
    step_list   = [0]

    interval    = 0.05      # unit: sec
    step_len    = 20        # number of elements in X axis
    total_step  = 0

    while True:
        try:
            ch0_list.append(hat.a_in_read(0, options))
            ch1_list.append(hat.a_in_read(1, options))
            step_list.append(total_step)

            if len(step_list) > step_len:
                del ch0_list[0]
                del ch1_list[0]
                del step_list[0]

            plt.cla()

            plt.plot(ch0_list, label="ch0")
            plt.plot(ch1_list, label="ch1")
            plt.xlim(1, len(step_list))
            plt.xticks([])
            plt.ylabel("voltage")
            plt.yticks([0, 1, 2, 3, 4, 5])
            plt.legend()
            plt.grid()

            plt.draw()

            plt.pause(interval)
            total_step += 1

        except KeyboardInterrupt:
            break

if __name__ == '__main__':
    main()

#include 
#include 
#include "daqhats_utils.h"  // daqhats\examples\c\daqhats_utils.h

#define RATE_SPS        100000.0    // max 100ksps
#define SAMPLE_DURATION 1.0         // sec
#define CHANNEL         0
#define OUT_FNAME       "out.csv"

#define BUFFER_SIZE     ((unsigned int)(SAMPLE_DURATION * RATE_SPS))

int main()
{
    uint8_t     brd_addr;   // board address
    double      *buf;
    uint32_t    total_read;
    uint32_t    read_num;
    uint16_t    read_status;

    uint32_t    options = OPTS_DEFAULT;
    int         i;

    // select the device to be used.
    if (select_hat_device(HAT_ID_MCC_118, &brd_addr) != 0) {
        return 1;
    }
    printf("MCC118 address = %d\n", brd_addr);

    // open a connection
    if (mcc118_is_open(brd_addr) == 0) {
        if (mcc118_open(brd_addr) != RESULT_SUCCESS) {
            printf("open failure\n");
            return 1;
        }
    }

    // allocate buffer
    buf = (double *)malloc(sizeof (double) * BUFFER_SIZE);
    if (buf == (double *)NULL) {
        fprintf(stderr, "malloc() error\n");
        return 1;
    }

    // start fast sampling
    if (mcc118_a_in_scan_start(brd_addr, CHANNEL, BUFFER_SIZE, RATE_SPS, options) != RESULT_SUCCESS) {
        fprintf(stderr, "start() error\n");
        return 1;
    }
    fprintf(stderr, "sampling start\n");

    // read all data
    total_read  = 0;
    do {
        mcc118_a_in_scan_read(brd_addr, &read_status, -1, -1, buf + total_read, BUFFER_SIZE - total_read, &read_num);
        total_read  += read_num;

        if (read_status & STATUS_HW_OVERRUN) {
            printf("\n\nhardware overrun (%d)\n", total_read);
            break;
        }
        else if (read_status & STATUS_BUFFER_OVERRUN) {
            printf("\n\nbuffer overrun (%d)\n", total_read);
            break;
        }
    } while ( (read_status & STATUS_RUNNING) == STATUS_RUNNING && total_read < BUFFER_SIZE);

    fprintf(stderr, "sampling end\n");

    // write file
    FILE    *fpout  = fopen(OUT_FNAME, "wt");
    for (i = 0; i < BUFFER_SIZE; i++) {
        fprintf(fpout, "%f, %f\n", (1.0 / RATE_SPS) * (double)i, buf[i]);
    }
    fclose(fpout);

    free(buf);
    mcc118_close(brd_addr);
    return 0;
}