Class Interface¶

Defined in File astrocam.h

Nested Relationships¶

Nested Types¶

Inheritance Relationships¶

Base Type¶

public Camera::InterfaceBase

Class Documentation¶

class Interface : public Camera::InterfaceBase ¶

This class defines the interface to the AstroCam controller.

Public Functions

inline Interface()¶

inline long init_pubsub(const std::initializer_list<std::string> &topics = {})¶

inline void start_subscriber_thread()¶

inline void stop_subscriber_thread()¶

void publish_status(bool force = false)¶

void request_snapshot()¶

void handletopic_snapshot(const nlohmann::json &jmessage_in)¶

void handletopic_calib(const nlohmann::json &jmessage_in)¶

void handletopic_flexure(const nlohmann::json &jmessage_in)¶

void handletopic_focus(const nlohmann::json &jmessage_in)¶

void handletopic_power(const nlohmann::json &jmessage_in)¶

void handletopic_slit(const nlohmann::json &jmessage_in)¶

void handletopic_targetinfo(const nlohmann::json &jmessage_in)¶

void handletopic_tcs(const nlohmann::json &jmessage_in)¶

void handletopic_thermal(const nlohmann::json &jmessage_in)¶

inline void add_framethread()¶

inline void remove_framethread()¶

inline int get_framethread_count()¶

inline void init_framethread_count()¶

inline bool is_camera_idle(int dev)¶

is the specified camera idle?

Asking if a camera is idle refers to its activity status — actively reading out or in frame transfer.

Parameters:: dev – [in] device number to check
Returns:: true|false

inline bool is_camera_idle()¶

inline bool in_readout() const¶

inline bool in_frametransfer() const¶

inline void inc_expbuf()¶

inline int get_expbuf()¶

inline std::vector<int> exposure_pending_list()¶

returns the exposure_pending vector

Returns:: std::vector<int>

inline bool exposure_pending()¶

Is an exposure pending or can a new exposure be started?

This function is overloaded with a version that allows setting the exposure_pending state.

Returns:: bool { true | false }

inline void exposure_pending(int devnum, bool add)¶

Set or clear the exposure pending state for a given controller.

This function is overloaded with an inline version that returns a bool to indicate if there are any controllers with a pending exposure.

Parameters:

devnum – [in] controller device number
add – [in] bool true to add, false to remove from pending vector

inline std::vector<int> writes_pending_list(int expbuf)¶

returns the writes_pending vector

Parameters:: expbuf – [in] the exposure buffer number
Returns:: std::vector<int>, the vector of devnums for this expbuf

inline bool any_writes_pending()¶

Is any device still writing frames for any exposure buffer?

Returns:: true if any writes are pending, false otherwise

inline void write_pending(int expbuf, int devnum, bool add)¶

Set or clear the write pending state for a given exposure.

This function is overloaded with an inline version that returns a bool to indicate if there are any controllers with a pending write.

Parameters:

expbuf – [in] exposure buffer number
devnum – [in] device number
add – [in] bool true to add, false to remove from pending vector

void get_logical(Controller *pcontroller, int &spat, int &spec, int &osspat, int &osspec, int &binspat, int &binspec)¶

long camera_active_state(const std::string &args, std::string &retstring, AstroCam::ActiveState cmd)¶

Controller *get_controller(const int dev)¶

Controller *get_active_controller(const int dev)¶

void exposure_progress()¶

void make_image_keywords(int dev)¶

long parse_spec_info(std::string args)¶

long parse_det_geometry(std::string args)¶

long parse_controller_config(std::string args)¶

long parse_activate_commands(std::string args)¶

int devnum_from_chan(const std::string &chan)¶

long extract_dev_chan(std::string args, int &dev, std::string &chan, std::string &retstring)¶

long test(std::string args, std::string &retstring)¶: test routines

void dothread_test_shutter_timer(long ms)¶

long interface(std::string &iface)¶: returns the interface

long do_abort()¶

long abort()¶

long do_bin(std::string args, std::string &retstring)¶: set/get binning factor

long bin(std::string args, std::string &retstring)¶: set/get binning factor

long do_connect_controller(const std::string devices_in, std::string &retstring)¶: opens a connection to the PCI/e device(s)

long connect_controller(std::string devices_in, std::string &help)¶: wrapper for do_connect_controller

long is_connected(std::string &retstring)¶: are all selected controllers connected?

long do_disconnect_controller(int dev)¶: closes the connection to the named PCI/e device

long do_disconnect_controller()¶: closes the connection to all PCI/e devices

long disconnect_controller()¶: wrapper for do_disconnect_controller

long do_configure_controller()¶: perform initial configuration of controller from .cfg file

long configure_controller()¶: wrapper for do_configure_controller

long access_useframes(std::string &useframes)¶: set or get the state of this->useframes

long access_nframes(std::string valstring)¶

int get_driversize()¶

long do_load_firmware(std::string &retstring)¶: load firmware (.lod) into one or all controller timing boards

long do_load_firmware(std::string timlodfile, std::string &retstring)¶

long load_firmware(std::string &retstring)¶: wrapper for load_firmware

long load_firmware(std::string timlodfile, std::string &retstring)¶: wrapper for load_firmware

long band_of_interest(std::string args, std::string &retstring)¶: set/get interest bands

long parse_boi_pairs(Controller *pcontroller, const std::string &args)¶

long load_boi_pairs(Controller *pcontroller, int &spat_total)¶

long reset_boi_full(Controller *pcontroller, int dev, const std::string &chan, std::string &retstring)¶

long adjust_boi_for_binning(Controller *pcontroller, int nskip, int nread, std::pair<int, int> &adj)¶

std::string print_bands_of_interest(Controller *pcontroller)¶

long set_camera_mode(std::string mode)¶

long exptime(std::string exptime_in, std::string &retstring)¶

long do_exptime(std::string exptime_in, std::string &retstring)¶

long modify_exptime(std::string exptime_in, std::string &retstring)¶

long do_modify_exptime(std::string exptime_in, std::string &retstring)¶

long stop_exposure(std::string exptime_in, std::string &retstring)¶

long pause_exposure(std::string exptime_in, std::string &retstring)¶

long resume_exposure(std::string exptime_in, std::string &retstring)¶

long shutter(std::string shutter_in, std::string &shutter_out)¶

long frame_transfer_mode(std::string args)¶

long frame_transfer_mode(std::string args, std::string &retstring)¶

long image_size(std::string args, std::string &retstring)¶

long set_image_size(Controller *pcontroller, int spat, int spec, int osspat, int osspec, int binspat, int binspec)¶

long geometry(std::string args, std::string &retstring)¶

long do_geometry(std::string args, std::string &retstring)¶

long bias(std::string args, std::string &retstring)¶

long buffer(std::string size_in, std::string &retstring)¶

long readout(std::string readout_in, std::string &readout_out)¶

long do_readout(std::string readout_in, std::string &readout_out)¶

void set_imagesize(int rowsin, int colsin, int *status)¶

long expose(std::string nexp_in)¶

long do_expose(int nexp_in)¶

double get_live_airmass()¶: latest airmass from cached tcsd telemetry, or NAN

long native(std::string cmdstr)¶

long native(std::string cmdstr, std::string &retstring)¶

long do_native(std::string cmdstr)¶

selected or all open controllers

send 3-letter command to …

long do_native(std::string cmdstr, std::string &retstring)¶: selected or all open controllers, return reply

long do_native(std::vector<int> selectdev, std::string cmdstr)¶: specified by vector

long do_native(std::vector<int> selectdev, std::string cmdstr, std::string &retstring)¶: specified by vector

long do_native(int dev, std::string cmdstr, std::string &retstring)¶: specified by devnum

long do_native(int dev, std::string cmdstr)¶: specified by devnum

long write_frame(int expbuf, int devnum, const std::string chan, int fpbcount)¶

void dothread_native(int dev, std::vector<uint32_t> cmd)¶

void handle_queue2(std::string message)¶

inline int keytype_string()¶

inline int keytype_double()¶

inline int keytype_integer()¶

inline int fits_bpp16()¶

inline int fits_bpp32()¶

Public Members

Config config¶

Camera::Camera camera¶

Camera::Information camera_info¶: instantiate a Camera object

std::map<std::string, nlohmann::json> live_telemetry¶

this is the main camera_info object

latest JSON snapshot per provider, keyed by Topic

std::mutex live_telemetry_mtx¶

std::unique_ptr<Common::PubSub> publisher¶: publisher object

std::string publisher_address¶: publish socket endpoint

std::string publisher_topic¶: my default topic for publishing

std::unique_ptr<Common::PubSub> subscriber¶: subscriber object

std::string subscriber_address¶: subscribe socket endpoint

std::vector<std::string> subscriber_topics¶: list of topics I subscribe to

std::atomic<bool> is_subscriber_thread_running¶: is my subscriber thread running?

std::atomic<bool> should_subscriber_thread_run¶: should my subscriber thread run?

std::unordered_map<std::string, std::function<void(const nlohmann::json&)>> topic_handlers¶: maps a handler function to each topic

Common::Broadcaster broadcast = {this->publisher, Daemon::CAMERAD}¶

std::vector<std::shared_ptr<Camera::Information>> fitsinfo¶

std::mutex frameinfo_mutex¶: protects access to frameinfo

std::mutex framecount_mutex¶: protects access to frame count

std::atomic<int> framethreadcount¶

std::mutex framethreadcount_mutex¶

std::atomic<bool> state_monitor_thread_running¶

std::condition_variable state_monitor_condition¶

std::mutex state_lock¶

Status status¶

Status last_published_status¶

std::mutex publish_mutex¶: serializes concurrent callers of publish_status()

std::condition_variable exposure_condition¶

std::mutex exposure_lock¶

std::condition_variable write_condition¶

std::mutex write_lock¶

std::map<int, Controller> controller¶

bool modeselected¶: true if a valid mode has been selected, false otherwise

bool useframes¶: Not all firmware supports frames.

std::vector<FITS_file*> pFits¶: vector of FITS containers, one for each exposure number for multiple buffering

std::map<std::string, readout_info_t> readout_source¶: STL map of readout sources indexed by readout name.

Public Static Functions

static void state_monitor_thread(Interface &interface)¶

static void dothread_monitor_exposure_pending(Interface &interface)¶

static void dothread_load(Controller &con, std::string timlodfile)¶

static void dothread_shutter(int expbuf, Interface &interface)¶

static void dothread_read(Camera::Camera &cam, Controller &con, int expbuf)¶

static void dothread_expose(Controller &con)¶

static void handle_frame(int expbuf, int devnum, uint32_t fpbcount, uint32_t fcount, void *buffer)¶

static void handle_queue(std::string message)¶

static void FITS_handler(int expbuf, Interface &interface)¶

class Controller¶

contains information for each controller

The Controller class is a sub-class of Interface and is here to contain the Camera::Information class and FITS_file class objects. There will be a vector of Controller class objects which matches the vector of controller objects.

Public Types

enum Axis¶

Values:

enumerator ROW¶

enumerator COL¶

Public Functions

inline Controller()¶

inline ~Controller()¶

void logical_to_physical(int spat, int spec, int &rows, int &cols) const¶

void physical_to_logical(int rows, int cols, int &spat, int &spec) const¶

inline int spat_physical_axis() const¶

inline int spec_physical_axis() const¶

inline bool has_boi() const¶

inline uint32_t get_bufsize()¶

inline uint32_t set_bufsize(uint32_t sz)¶

long alloc_workbuf()¶

inline void init_framecount()¶

inline int get_framecount()¶

inline void increment_framecount()¶

template<class T> T *deinterlace(int expbuf, T *imbuf)¶

template<class T> void *alloc_workbuf(T *buf)¶

template<class T> void free_workbuf(T *buf)¶

long write()¶: wrapper for this->pFits->write_image()

long open_file(std::string writekeys)¶: wrapper for this->pFits->open_file()

void close_file(std::string writekeys)¶: wrapper for this->pFits->close_file()

Public Members

Camera::Information info¶

no deconstructor

camera info object for this controller

void *workbuf¶: pointer to workspace for performing deinterlacing

std::vector<Camera::Information> expinfo¶

vector of Camera::Information class, one for each exposure buffer

This contains the camera information for each exposure buffer. Note that since Camera::Information contains extkeys and prikeys objects, expinfo will contain those objects, but prikeys should not be used. Use only Controller::expinfo.extkeys because keys specific to a given controller will be added to that controller’s extension.

std::mutex pcimtx¶: mutex protects talking to this PCI driver

int error¶

int cols¶: total number of columns read (includes overscan)

int rows¶: total number of rows read (includes overscan)

Axis spec_axis¶: which physical axis {ROW,COL} is spectral

Axis spat_axis¶: which physical axis {ROW,COL} is spatial

int detcols¶: number of detector columns (unchanged by binning)

int detrows¶: number of detector rows (unchanged by binning)

int oscols0¶: requested number of overscan rows

int osrows0¶: requested number of overscan columns

int oscols¶: realized number of overscan rows (can be modified by binning)

int osrows¶: realized number of overscan columns (can be modified by binning)

int skiprows¶

int skipcols¶

int defcols¶: default number of detector columns

int defrows¶: default number of detector rows

int defoscols¶: default number of overscan rows

int defosrows¶: default number of overscan columns

int defbincols¶: default number of overscan rows

int defbinrows¶: default number of overscan columns

std::string imsize_args¶: IMAGE_SIZE arguments read from config file, used to restore default.

arc::gen3::CArcDevice *pArcDev¶: arc::CController object pointer — things pointed to by this are in the ARC API

Callback *pCallback¶: Callback class object must be pointer because the API functions are virtual.

bool connected¶: true if controller connected (requires successful TDL command)

bool configured¶: set false to skip future use of controllers when unable to connect

bool active¶: used to disable an otherwise-configured controller

bool is_imsize_set¶: has image_size been called after controller connected?

bool firmwareloaded¶: true if firmware is loaded, false otherwise

std::string firmware¶: name of firmware (.lod) file

std::string channel¶: name of spectrographic channel

std::string ccd_id¶: CCD identifier (E.G. serial number, name, etc.)

int devnum¶: this controller’s devnum

std::string devname¶: comes from arc::gen3::CArcPCI::getDeviceStringList()

std::uint32_t retval¶: convenient place to hold return values for threaded commands to this controller

std::map<int, frameinfo_t> frameinfo¶: STL map of frameinfo structure (see above)

uint32_t readout_arg¶

bool have_ft¶: Do I have (and am I using) frame transfer?

std::atomic<bool> in_readout¶: Is the controller currently reading out/transmitting pixels?

std::atomic<bool> in_frametransfer¶: Is the controller currently performing a frame transfer?

std::vector<std::string> activate_commands¶

Public Static Functions

template<class T> static void dothread_deinterlace(DeInterlace<T> &deinterlace, int cols, int rows, int section, int nthreads)¶

struct frameinfo_t¶

Public Members

int tid¶: use fpbcount as the thread ID here

int framenum¶: the current frame from ARC_API’s fcount, counts from 1

int rows¶: number of rows in this frame

int cols¶: number of cols in this frame

void *buf¶: pointer to the start of memory holding this frame

bool inuse¶: this thread ID is in use, set when thread is spawned, cleared when handle_frame is done

struct readout_info_t¶

Public Members

ReadoutType readout_type¶: enum for readout type

uint32_t readout_arg¶: argument for Arc firmware command

struct Status¶

Public Functions

Status() = default¶

inline Status(const Status &o)¶

inline Status &operator=(const Status &o)¶

inline bool operator==(const Status &other) const¶

Public Members

bool in_readout = {false}¶

std::atomic<bool> can_expose = {true}¶

bool is_exposing = {false}¶

bool is_paused = {false}¶

bool is_shutteropen = {false}¶