cosmoz.h

[詳解]

/**************************************************************************/
#ifndef H_COSMOZ
#define H_COSMOZ

#include <stdio.h>
#include <stdint.h>
#include <time.h>

// 基本的な値の定義

#define FIRMWARE_VERSION 0x02000301
#define FIRMWARE_DATE    0x20171025

#define MAX_REGS 64 
#define MAX_EXTCH 4

#ifndef NULL
#define NULL ((void *)0) 
#endif

#ifndef BOOL
#define BOOL int 
#endif

#ifndef TRUE
#define TRUE 1 
#endif

#ifndef FALSE
#define FALSE 0 
#endif

typedef struct ADC_INFO {
    int    basefreq;           
    int    decimation_ratio;   
    double sampling_freq_mhz;  
    int    adc_num;            
    BOOL   testmode;           
    int    device_max_freq;    
    int    device_resolution;  
    int    current_resolution; 
    char   device_type[8][32]; 
} ADC_INFO ;

typedef struct ANALOG_CH_INFO {
    double input_min_voltage;  
    double input_max_voltage;  
    double filter_fc;          
    double gain;               
} ANALOG_CH_INFO;

// ユーザ公開 API関数の定義
#if __cplusplus
extern "C" {
#endif

/***********************************************************************************!
//　ドライバ基本関数
************************************************************************************/

BOOL csz_open();

uint32_t csz_firmware_version();

uint32_t csz_firmware_date();

uint32_t csz_driver_version();

uint32_t csz_fpga_version();

void csz_close();

uint64_t csz_time48();

/***********************************************************************************!
//　低レベルなメモリ/レジスタ操作関数
************************************************************************************/

uint32_t csz_reg_read(int regnum);

// 
BOOL csz_reg_write(int regnum,uint32_t val);

int csz_mem_read(uint32_t addr, int len, void *buf);

int csz_mem_write(uint32_t addr, int len, void *buf);

void csz_mem_info(uint32_t *base_addr, ssize_t *size);

void csz_mem_dump(int offset, int len);

BOOL csz_mem_test();

char *csz_get_error();


/***********************************************************************************!
//　ADC操作関数
************************************************************************************/

uint32_t csz_adc_val(int ch);

void csz_adc_reset();

BOOL csz_adc_freq(int freq);

int csz_adc_getfreq();

void csz_adc_getinfo(ADC_INFO *info);

void csz_adc_testmode(BOOL on,int option);

BOOL csz_adc_is_testmode();

int csz_adc_maxch();

void csz_adc_calstat();

void csz_adc_enumerate(int *adcnum,char partnum[8][32]);

void csz_adc_regdump();

/***********************************************************************************!
// 波形キャプチャ関数
************************************************************************************/

typedef enum {
    CAPSTAT_IDLE,            
    CAPSTAT_TRIGWAIT,        
    CAPSTAT_RUN,             
} CAPTURE_STATUS;

typedef enum {
    CAPRESULT_SUCCESS,         
    CAPRESULT_ABORTED,         
    CAPRESULT_ERROR,           
    CAPRESULT_ANOTHERRUN,      
    CAPRESULT_TRIGGER_TIMEOUT, 
} CAPTURE_RESULT;

typedef enum  {
    CAPTRIG_AUTO,           
    CAPTRIG_NORMAL,         
    CAPTRIG_IMMEDIATE,      
    CAPTRIG_LONG            
} CAPTURE_TRIGGER;

typedef struct CAPTURE_INFO {
    CAPTURE_RESULT result; 
    uint32_t chmask;       
    int chcount;           
    int length;            
    int iteration;         
    CAPTURE_TRIGGER trig;  
    time_t start_time;     
    time_t end_time;       
    double sampling_rate;  
    int adc_freq;          
    int adc_div;           
    int resolution;        
    uint32_t gps_time;     
    uint32_t gps_10ns;     
    uint32_t gps_maxcount; 
    uint64_t start_time48; 
    uint32_t top_addr;     
    uint32_t bot_addr;     
    uint32_t last_addr;    
    // 以下はイベントキャプチャで使う
    int mesp;              
    int evcount;           
    int prev_capaddr;      
} CAPTURE_INFO;

CAPTURE_INFO csz_capture_execute(uint32_t chmask,int length,CAPTURE_TRIGGER type);

void csz_capture_datacopy(CAPTURE_INFO info, int ch, uint16_t *result);

void csz_capture_datacopy32(CAPTURE_INFO info, int ch, uint32_t *result);

void csz_capture_timeout(int ms);

int csz_capture_get_timeout();

void csz_capture_abort();

CAPTURE_STATUS csz_capture_status();

/***********************************************************************************!
* イベントキャプチャ
************************************************************************************/

typedef struct EVHEADER_STR {
    int      evcount;
    uint16_t hdr;
    uint8_t  ch;
    uint16_t length;
    uint64_t time48;
    uint16_t plsh;
    uint16_t sum;
    uint16_t ped;
    uint16_t meslen;
    int      mesp;
} EVHEADER_STR;

typedef BOOL (*CALLBACK_EVENTCAP)(uint16_t *data,int datacount);

CAPTURE_INFO csz_evcap_execute(uint32_t chmask,int count, CALLBACK_EVENTCAP func);
BOOL csz_evcap_get_next(CAPTURE_INFO *info,EVHEADER_STR *hdr,uint16_t *data);

/***********************************************************************************!
* トリガの設定
************************************************************************************/

typedef enum  {
    TRIGTYPE_OFF,           
    TRIGTYPE_UPPER,         
    TRIGTYPE_LOWER,         
    TRIGTYPE_CROSS,         
    TRIGTYPE_DISCRI,        
    TRIGTYPE_RISE,          
    TRIGTYPE_FALL,          
    TRIGTYPE_LINKAGE,       
    TRIGTYPE_USER,          
    TRIGTYPE_ERROR          
} TRIGTYPE;

typedef enum  {
    EXTTRIGTYPE_OFF,        
    EXTTRIGTYPE_RISE,       
    EXTTRIGTYPE_FALL,       
    EXTTRIGTYPE_HIGH,       
} EXTTRIGTYPE;

void csz_trig_ortrig(BOOL ortrig);

BOOL csz_trig_is_ortrig();

BOOL csz_trig_set(int ch,TRIGTYPE type, int val);

BOOL csz_trig_set_voltage(int ch, TRIGTYPE type, double voltage);

TRIGTYPE csz_trig_gettype(int ch);

TRIGTYPE csz_trig_gettype(int ch);

int csz_trig_getadcval(int ch);

double csz_trig_getvoltage(int ch);

const char *csz_trig_tostr(TRIGTYPE type);

int csz_trig_rate(int ch);

int csz_trig_pulseheight(int ch);

int csz_trig_pedestal(int ch);

BOOL csz_pretrig_set(int pre);

void csz_pretrig_type(BOOL extend);

int csz_pretrig_get();

int csz_pretrig_max();

BOOL csz_posttrig_set(int pre);

int csz_posttrig_get();

void csz_posttrig_fixed(BOOL fixed);

BOOL csz_posttrig_is_fixed();

BOOL csz_exttrig_set(int extch, EXTTRIGTYPE type);

const char *csz_exttrig_tostr(EXTTRIGTYPE type);

EXTTRIGTYPE csz_exttrig_get(int extch);

/***********************************************************************************!
//　GPS関係
************************************************************************************/

BOOL csz_gps_time(uint32_t *gps_time, uint32_t *gps_10ns, uint32_t *gps_maxcount);

void csz_gps_settime(time_t time);

/***********************************************************************************!
* XADC処理
************************************************************************************/

double csz_xadc_tempe();

double csz_xadc_vccint();

double csz_xadc_vccaux();

double csz_xadc_vccddro();

/***********************************************************************************!
* エラー処理
************************************************************************************/

typedef enum {
    CSZERR_ILLEGAL_REGNUM,    
    CSZERR_MEMRANGE_OVERFLOW, 
    CSZERR_MEMADDR_ALIGNMENT, 
    CSZERR_UNSUPPORTED_FREQ,  
    CSZERR_ILLEGAL_CHNUM,     
    CSZERR_TRIGRANGE_OVER,    
} COSMOZ_ERROR;

void csz_set_error(COSMOZ_ERROR err);

/***********************************************************************************!
* その他
************************************************************************************/

double csz_point2us(int point);

int csz_us2point(double us);

void disable_ctrlc();

BOOL is_crtlc_pushed();

#if __cplusplus
}
#endif

#endif /* H_COSMOZ */