adc.h

Go to the documentation of this file.

#ifndef NEXUS_ADC_H
#define NEXUS_ADC_H
 
#include "nexus/core/time.h"
#include "nexus/io/adc_observer.h"
#include "nexus/io/stream.h"
#include "nexus/io/wake.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct nx_adc_port nx_adc_port_t;
typedef struct {
    uint8_t resolution_bits;
    uint32_t reference_mv;
    size_t channel_count;
} nx_adc_info_t;

typedef struct {
    const uint8_t* channels;
    const uint8_t* sample_times;
    const uint16_t* sample_cycles;
    size_t channel_count;
    size_t sample_code_count;
    uint32_t adc_clock_hz;
    uint32_t timer_clock_hz;
    uint32_t scan_cycles;
    uint16_t conversion_cycles;
} nx_adc_sequence_info_t;

typedef struct {
    nx_result_t (*info)(const void* context, nx_adc_info_t* info);
    nx_result_t (*sample)(void* context, uint16_t* samples, size_t capacity,
                          nx_time_us_t deadline, size_t* count);
    nx_result_t (*stream_start)(void* context, nx_stream_t* stream,
                                uint32_t trigger_hz);
    nx_result_t (*stream_stop)(void* context);
    nx_result_t (*stream_service)(void* context);
    nx_result_t (*attach_wake)(void* context, const nx_irq_wake_t* wake,
                               uint8_t syscall_ceiling);
    nx_result_t (*sequence_info)(const void* context,
                                 nx_adc_sequence_info_t* info);
    nx_result_t (*attach_observer)(void* context, nx_adc_observer_t* observer);
    nx_result_t (*block_observation)(const void* context,
                                     const nx_stream_block_t* block,
                                     nx_adc_observation_t* observation);
} nx_adc_ops_t;

struct nx_adc_port {
    const nx_adc_ops_t* ops;
    void* context;
};

nx_result_t nx_adc_port_info(const nx_adc_port_t* port, nx_adc_info_t* info);
nx_result_t nx_adc_port_sequence_info(const nx_adc_port_t* port,
                                      nx_adc_sequence_info_t* info);
nx_result_t nx_adc_port_attach_observer(const nx_adc_port_t* port,
                                        nx_adc_observer_t* observer);
nx_result_t nx_adc_port_block_observation(const nx_adc_port_t* port,
                                          const nx_stream_block_t* block,
                                          nx_adc_observation_t* observation);

nx_result_t nx_adc_port_sample(const nx_adc_port_t* port, uint16_t* samples,
                               size_t capacity, nx_time_us_t deadline,
                               size_t* count);
nx_result_t nx_adc_port_stream_start(const nx_adc_port_t* port,
                                     nx_stream_t* stream, uint32_t trigger_hz);
nx_result_t nx_adc_port_stream_stop(const nx_adc_port_t* port);
nx_result_t nx_adc_port_stream_service(const nx_adc_port_t* port);
nx_result_t nx_adc_port_attach_wake(const nx_adc_port_t* port,
                                    const nx_irq_wake_t* wake,
                                    uint8_t syscall_ceiling);
#ifdef __cplusplus
}
#endif
 
#endif