// ----------------------------------------------------------------------------
//  Copyright (C) 2008, Sealevel Systems
//  
//  For help please contact us by email at support@sealevel.com.
//
//  $Id: seamaxlin.h,v 1.11 2009/07/13 19:49:55 kmoody Exp $
// ----------------------------------------------------------------------------
#ifndef PUBLIC_DOCUMENTATION
/*! \mainpage   Linux SeaMax API Documentation
 *  \section   warning      Internal Disclaimer
 *
 *  <b>WARNING! This document is intended for internal use only.</b>
 */  
#else
/*! \mainpage Linux SeaMAX API Documentation
 *
 * \section intro_sec Introduction
 *
 * Sealevel digital and analog I/O modules supported by the SeaMAX software 
 * suite are designed to work with third party applications via the SeaMAX API.
 * To help simplify application development, the following documentation 
 * details the functions of the SeaMAX API.  To help you get started, example
 * C and C++ source code is provided.
 *
 * \section start Getting Started
 *
 * There are three modules that are included in the SeaMAX API:
 *
 * \li	<b>\ref group_seamax_all</b><br>
 *		The foundation of SeaMAX with functions for configuring, interfacing,
 *		and modifying supported Sealevel digital I/O modules and devices.
 * \li	<b>\ref group_cethernet_all</b><br>
 *		The Ethernet module contains functions related to the discovery and 
 *		configuration of Sealevel I/O devices with an Ethernet interface.
 * \li	<b>\ref modbusbreakdown</b><br>
 *		The Modbus Specification contains detailed descriptions of all RTU 
 *        and TCP Modbus commands applicable to SeaIO and SeaDAC modules.
 *
 * The 'Modules' tab above lists all SeaMAX modules and their functions.  For 
 * additional information regarding legacy products and technical 
 * specifications, please refer to the 'Related Pages' tab above.
 *
 * \section questions Questions & Comments
 *
 * Send your questions and comments to Sealevel Systems.  For technical 
 * assistance, please include your model or part number and any device
 * settings that may apply.  Technical support is available Monday to
 * Friday from 8:00AM to 5:00PM (US Eastern Time Zone, UTC-6 hours) by
 * email (support@sealevel.com) or by phone at +1 (864) 843.4343.
 */



/// \defgroup	group_seamax_all  SeaMAX API
/// The SeaMAX API consists of the functions outline below, and provides an
/// interface for construction, transmission, and reception of Modbus RTU and 
/// TCP commands.  For more information, click a function name below for 
/// detailed information on function use, parameter types, and return codes.
///
/// \note Not every function below may apply to your specific Sealevel I/O 
/// device.  Refer to the \ref modbusbreakdown "modbus breakdown".

/// \defgroup	group_cethernet_all	 SeaMAX Ethernet Discovery/Configuration API
///
/// The SeaMAX Ethernet Discover API includes functions used for configuration 
/// and discovery of Ethernet enabled Sealevel I/O devices.  For specifics,
/// click any of the function names below to view function use, parameters, and
/// return code information.

/// \ingroup	group_seamax_all
/// \defgroup	group_seamax_oop  Object-Oriented SeaMAX Modbus Interface
/// This is a C++ wrapper for the standard SeaMAX Modbus interface library.
/// This library is designed to aid in the construction, transmission, and
/// reception of Modbus RTU and TCP commands.  This library is designed for use
/// with Sealevel SeaIO modules.
///

/// \ingroup	group_seamax_all
/// \defgroup	group_seamax_fun  Functional SeaMAX Modbus Interface
/// This is a simple C library to aid in the construction, transmission, and 
/// reception of Modbus RTU and TCP commands.  This library is designed for use
/// with Sealevel SeaIO modules.
/// 

/// \ingroup	group_cethernet_all
/// \defgroup	group_cethernet_oop	 Object Oriented CEthernet Interface
/// This is a C++ wrapper for the standard CEthernet library.  This library is
/// designed to aid in the discovery and configuration of Ethernet enabled 
/// SeaIO modules.
/// 

/// \ingroup	group_cethernet_all
/// \defgroup	group_cethernet_fun	 Functional CEthernet Interface
/// This is a simple C library to aid in the discovery and configuration
/// of Ethernet enabled SeaIO modules.
/// 
#endif

#ifndef SEAMAXLIN_H__
#define SEAMAXLIN_H__

#include "thirdparty/ftdi.h"

// Sealevel vendor ID number
#define VENDOR	0x0c52

// This is used for proper inclusion when used with C++
#ifdef __cplusplus
	extern "C" {
#endif


// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \typedef SeaMaxLin
/// Pointer to a SeaMax object. The data structure this points to is private 
/// and should not be accessed directly, but through the function calls instead.
// ----------------------------------------------------------------------------
typedef long  		SeaMaxLin;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \typedef HANDLE 
/// A handle or pointer to another data structure.
/// This particular pointer is used to pass the serial communications struct.
// ----------------------------------------------------------------------------
typedef int   		HANDLE;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \typedef slave_address_t
/// The slave ID of a device.  This value can be from 1 to 247.
// ----------------------------------------------------------------------------
typedef unsigned char 	slave_address_t;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \typedef address_loc_t 
/// An address specific to your device.  Check read/write functions for 
/// specific use.
// ----------------------------------------------------------------------------
typedef unsigned short	address_loc_t;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \typedef address_range_t 
/// The range of address to be used.  Check read/write functions for specific
/// use.
// ----------------------------------------------------------------------------
typedef unsigned short 	address_range_t;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief The module connection type.  
/// Currently there is only support for RTU and TCP type connections.
// ----------------------------------------------------------------------------
typedef enum
{
	NO_CONNECT = 0,  ///< Connection not open.
	MODBUS_RTU = 1,  ///< An RTU type connection.  232, 485, USB.
	MODBUS_TCP = 2,   ///< An ethernet connection.
	FTDI_DIRECT = 3   ///< An ethernet connection.
} seaio_mode_t;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief The current baud rate used by a RTU type module.
/// If the module is TCP type, then BR9600, the default, will be used.
/// Note these are not the same values used by the termios library.
// ----------------------------------------------------------------------------
typedef enum
{
	BRNONE   =  0,   ///< Default value, no connection, or unkown baud rate.
	BR1200   =  1,   ///< 1200 baud.
	BR2400   =  2,   ///< 2400 baud.
	BR4800   =  3,   ///< 4800 baud.
	BR9600   =  4,   ///< 9600 baud.
	BR14400  =  5,   ///< 14400 baud.
	BR19200  =  6,   ///< 19200 baud.
	BR28800  =  7,   ///< 28800 baud.
	BR38400  =  8,   ///< 38400 baud.
	BR57600  =  9,   ///< 57600 baud.
	BR115200 = 10    ///< 115200 baud.
} baud_rates_t;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief The currently used parity.
/// Parity is a quick and simple method of checking for errors.  It doesn't 
/// work all the time, but it is very simple to implement.
// ----------------------------------------------------------------------------
typedef enum
{
	P_NONE = 0,     ///< No parity (Default).
	P_ODD  = 1,     ///< Odd parity.
	P_EVEN = 2      ///< Even parity.
} parity_t;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief The type of read / write to preform.
/// Note that not all types can be written.  For example an attempt to write to
/// D_INPUTS or INPUTREG would cause an EINVAL error.  Also you can not directly
/// write to SETUPREGS, you must use an appropriate Ioctl.
// ----------------------------------------------------------------------------
typedef enum
{
	COILS		= 1,  ///< Coils are any relay type outputs.
	D_INPUTS 		= 2,  ///< Digitial inputs.  Single bit inputs.
	HOLDINGREG 	= 3,  ///< Configuration registers.
	INPUTREG 		= 4,  ///< Registers only used on A/D type devices.
	SETUPREG 		= 5,  ///< Advanced device configuration registers.
	SEAMAXPIO 	= 6   ///< Programmable type I/O.
} seaio_type_t;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \ingroup	group_seamax_all
/// \brief The type of IOCTL operation desired.
/// Read the manual carefully when using these.  There are some specific
/// methods that must be followed to use correctly.
// ----------------------------------------------------------------------------
typedef enum
{
	IOCTL_READ_COMM_PARAM 	= 1,  ///< Read communication parameters.
	IOCTL_SET_ADDRESS		= 2,  ///< Set device slave ID.
	IOCTL_SET_COMM_PARAM	= 3,  ///< Set communication parameters.
	IOCTL_GET_PIO			= 4,  ///< Get direction of programmable I/O.
	IOCTL_SET_PIO			= 5,  ///< Set direction of programmable I/O.
	IOCTL_GET_ADDA_CONFIG	= 6,  ///< Get A/D configuration information.
	IOCTL_SET_ADDA_CONFIG		= 7,  ///< Set the A/D configuration.
	IOCTL_GET_EXT_CONFIG 		= 8,  ///< Extended module id (SeaDAC).
	IOCTL_GET_ADDA_EXT_CONFIG	= 9,  ///< Information about D/A jumpers.
} IOCTL_t;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief 48 Bit pio configuration.
/// This struct is contained within the \a SeaMAX_PIO_ioctl_s struct.  It is
/// used whenever retrieving or setting port direction on a PIO device with
/// 48 bits of I/O.
// ----------------------------------------------------------------------------
typedef struct PIO48_config_s
{
	unsigned char channel1;         ///< Bits 0-5 map ports 1-6. (0:O, 1:I)
} PIO48_config_s;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief 96 Bit pio configuration.
/// This struct is contained within the \a SeaMAX_PIO_ioctl_s struct.  It is
/// used whenever retrieving or setting port direction on a PIO device with
/// 96 bits of I/O. 
// ----------------------------------------------------------------------------
typedef struct PIO96_config_s
{
	unsigned char channel1;         ///< Bits 0-5 map ports 1-6. (0:O, 1:I)
	unsigned char channel2;         ///< Bits 0-5 map ports 7-12. (0:O, 1:I)
} PIO96_config_s;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief This struct is used to set the address of a particular device.
/// In this way, it becomes unnecessary to manually turn the screw terminal to
/// configure a particular SeaIO device.  It also allows for more devices than
/// the physically selectable 15 addresses.
// ----------------------------------------------------------------------------
typedef struct seaio_ioctl_address_s
{
	unsigned char new_address;      ///< Address value from 1 to 247.
} seaio_ioctl_address_s;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief Communication parameters (desired) struct.
/// This struct can be used to set a desired communication configuration.
/// Note that you must first call get params before you attempt to set params,
/// or it will fail.
// ----------------------------------------------------------------------------
typedef struct seaio_ioctl_comms_s
{
	baud_rates_t new_baud_rate;     ///< Desire baud rate (/a baud_rates_t).
	parity_t new_parity;            ///< Desire parity (/a parity_t).
} seaio_ioctl_comms_s;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief Communication parameters (current) struct.
/// This struct can be used to store the current communication parameters.
/// Note that you will have call get params before you may set a configuration,
/// or it will fail.
// ----------------------------------------------------------------------------
typedef struct seaio_ioctl_get_params_s
{
	unsigned short 	model;        ///< Device model number (410, 462, ...)
	unsigned char  	bridge_type;  ///< Bridge type (M, E, U, S, or N).
	baud_rates_t 	baud_rate;    ///< The device's communication baud rate.
	parity_t 	parity;       ///< The device's communication parity.
	unsigned char	magic_cookie; ///< \internal Multithread saftey.
} seaio_ioctl_get_params_s;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief PIO data/setup struct.
/// This struct can be used to read data from a PIO device, or configure a PIO
/// device.
// ----------------------------------------------------------------------------
typedef struct SeaMAX_PIO_ioctl_s
{
	unsigned short model;         ///< Device model number (462, 463, ...)
	union
	{
		PIO48_config_s PIO48; ///< PIO directions /a PIO48_config_s
		PIO96_config_s PIO96; ///< PIO directions /a PIO96_config_s
	} config_state;
} SeaMAX_PIO_ioctl_s;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief PIO data/setup struct.
/// This struct can be used to read data from a PIO device, or configure a PIO
/// device.
// ----------------------------------------------------------------------------
typedef struct seaio_ioctl_ext_config
{
	unsigned short model;	     ///< Device model number (SeaDAC)
} seaio_ioctl_ext_config;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief The IOCTL struct used in the majority of the IOCTL calls.
/// Every call except the three involving A/D and D/A converters use this 
/// struct.  This struct is actually the union of several smaller structs, so 
/// that it can be used multiple times.
// ----------------------------------------------------------------------------
typedef struct seaio_ioctl_s
{
	union
	{
		seaio_ioctl_address_s	  address; ///< IOCTL_SET_ADDRESS
		seaio_ioctl_comms_s	  comms;   ///< IOCTL_READ_COMM_PARAM
		seaio_ioctl_get_params_s  params;  ///< IOCTL_SET_COMM_PARAM
		SeaMAX_PIO_ioctl_s	  pio;     ///< IOCTL_GET/SET_PIO
		seaio_ioctl_ext_config	  config;  ///< IOCTL_GET_EXT_CONFIG
	} u;    ///< Keep size down to largest struct inside.
} seaio_ioctl_s;

// ----------------------------------------------------------------------------
// | ADDA structs and types.                                                  |
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief ADDA conversion range configuration type.
/// This is the range of voltages that the A/D will convert into values from
/// 0x000 to 0xFFF (0-4095).  Plus to minus conversions do use a sign bit, so
/// 4095 is not necessarily the highest value.
// ----------------------------------------------------------------------------
typedef enum
{
	ZERO_TO_FIVE	= 0,   ///<   0-5V  (0x000-0xFFF)
	PLS_MIN_FIVE	= 1,   ///<  -5-5V  (0x800-0x7FF)
	ZERO_TO_TEN	= 2,   ///<   0-10V (0x000-0xFFF)
	PLS_MIN_TEN	= 3    ///< -10-10V (0x800-0x7FF)
} channel_range_type;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// ADDA mode configuration type.
/// This is how the board is physically configured to read Analog signals.  The
/// way to measure.  You can either measure 16 signals with a single common
/// ground, 8 isolated signals, or the current pulled through internal resistors
/// from 8 separate signals.
// ----------------------------------------------------------------------------
typedef enum
{
	SINGLE_ENDED	= 0,   ///< 16 common ground channels.
	DIFFERENTIAL	= 1,   ///< 8 differential channels.
	CURRENT_LOOP	= 2    ///< 8 current loop measurements.
} channel_mode_type;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief ADDA reference type configuration.
/// This controls the mux that is in charge of input to the single A/D chip on
/// an A/D capable device.  This provides some small A/D diagnostics if you
/// desire to use them.
// ----------------------------------------------------------------------------
typedef enum
{
	ANALOG_OFFSET	= 0,   ///< The A/D inputs available on the device.
	GND_OFFSET	= 1,   ///< A ground value.  Should always read 0V.
	AD_REF_OFFSET	= 2,   ///< A/D reference value.  Should always read 0V.
	DA_CHANNEL_1	= 4,   ///< D/A channel one as input.
	DA_CHANNEL_2	= 8    ///< D/A channel two as input.
} ad_reference_type;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief  The ADDA data struct used in the ADDA ioctl calls.
/// Contains information about device configuration.
// ----------------------------------------------------------------------------
typedef struct adda_config
{
     /// Overall device settings.
	struct 
	{
		unsigned char reference_offset;  ///< A/D Mux address.
		unsigned char channel_mode;      ///< Measurement mode.

	} device;

	/// Each channel uses 2 bits for configuration.
	/// Each of the bytes in this struct uses the lowest
     /// two bits for each channel configuration.
	struct
	{
		unsigned char ch_1;
		unsigned char ch_2;
		unsigned char ch_3;
		unsigned char ch_4;
		unsigned char ch_5;
		unsigned char ch_6;
		unsigned char ch_7;
		unsigned char ch_8;
		unsigned char ch_9;
		unsigned char ch_10;
		unsigned char ch_11;
		unsigned char ch_12;
		unsigned char ch_13;
		unsigned char ch_14;
		unsigned char ch_15;
		unsigned char ch_16;

	} channels;
} adda_config;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief Data struct returned by get ext adda ioctl.
/// Contains information about the physical jumper configuration of the device.
// ----------------------------------------------------------------------------
typedef struct adda_ext_config
{
	unsigned char		ad_multiplier_enabled;  ///< A/D amplifier.

	channel_range_type	da_channel_1_range;     ///< D/A1 range.
	channel_range_type	da_channel_2_range;     ///< D/A2 range 
} adda_ext_config;

// ----------------------------------------------------------------------------
/// \ingroup	group_seamax_all
/// \brief SeaDAC Lite range configuration type.
/// This is the range of available SeaDAC products
// ----------------------------------------------------------------------------
typedef enum
{
	SDL_8111	=  0x8111,	///<  4 inputs and 4 reed outputs
	SDL_8112,				///<  4 inputs and 4 form-c outputs
	SDL_8113,				///<  4 inputs
	SDL_8114,				///<  4 reed outputs
	SDL_8115,				///<  4 form-c outputs
	SDL_8126	=  0x8126	///<  32 TTL I/O
} sdl_range_type;

typedef enum 
{
	SCL = 0x01, SDA = 0x02, TDO = 0x04, CS = 0x08,
	GPIO_0 = 0x01, GPIO_1 = 0x02, GPIO_2 = 0x04, GPIO_3 = 0x08, 
	GPIO_4 = 0x10, GPIO_5 = 0x20, GPIO_6 = 0x40, GPIO_7 = 0x80
} sdl_i2c_type;

// ----------------------------------------------------------------------------
// SeaMaxModule struct.
// This structure is used internally to keep track of a module that open() has
// been called on.
// ----------------------------------------------------------------------------
typedef struct seaMaxModule
{
	int throttle;                   //Throttling delay for RTU mode.
	seaio_mode_t commMode;          //Communication medium (RTU or TCP).
	HANDLE hDevice;                 //Device comm interface.
	int mutex;                      //Multithread (force sequential).
	struct termios *initalConfig;   //Original serial configuration.
	struct ftdi_context ftdic;		//For SeaDAC Lite modules
	int deviceType;
	
} seaMaxModule;

// ----------------------------------------------------------------------------
// |                             private prototypes                           |
// ----------------------------------------------------------------------------
int InitializeI2C(seaMaxModule*);
void ExecuteQueue(seaMaxModule*);
void InitializeQueue(void);
void ExecuteQueue(seaMaxModule*);
void ReadRegister(unsigned char, unsigned char, unsigned char*);
void WriteRegister(unsigned char, unsigned char, unsigned char);
void SetGPIO(unsigned char, unsigned char);

// ----------------------------------------------------------------------------
// |                             API prototypes                               |
// ----------------------------------------------------------------------------

SeaMaxLin *SeaMaxLinCreate(void);
int SeaMaxLinDestroy(SeaMaxLin *SeaMaxPointer);
int SeaMaxLinOpen(SeaMaxLin *SeaMaxPointer, char *filename);
int SeaMaxLinClose(SeaMaxLin *SeaMaxPointer);

int SeaMaxLinRead(SeaMaxLin *SeaMaxPointer, slave_address_t slaveId, 
		  seaio_type_t type, address_loc_t starting_address,
		  address_range_t range, void *data);

int SeaDacLinRead(SeaMaxLin *SeaMaxPointer, unsigned char *data, 
			int numBytes);

int SeaMaxLinWrite(SeaMaxLin *SeaMaxPointer, slave_address_t slaveId, 
		  seaio_type_t type, address_loc_t starting_address,
		  address_range_t range, unsigned char *data);

int SeaDacLinWrite(SeaMaxLin *SeaMaxPointer, unsigned char *data, 
			int numBytes);

int SeaMaxLinIoctl(SeaMaxLin *SeaMaxPointer, slave_address_t slaveId,
		  IOCTL_t which, void *data);

int SeaMaxLinSetIMDelay(SeaMaxLin *SeaMaxPointer, int delay);

int SeaDacGetPIO(SeaMaxLin *SeaMaxPointer, unsigned char* data);

int SeaDacSetPIO(SeaMaxLin *SeaMaxPointer, unsigned char* data);

int SeaDacSetPIODirection(SeaMaxLin *SeaMaxPointer, unsigned char* data);

int SeaDacGetPIODirection(SeaMaxLin *SeaMaxPointer, unsigned char* data);

HANDLE SeaMaxLinGetCommHandle(SeaMaxLin *SeaMaxPointer);



// ----------------------------------------------------------------------------
// | End of C library function calls.                                         |
// ----------------------------------------------------------------------------
#ifdef __cplusplus
	}

class CSeaMaxLin {
public:

	CSeaMaxLin(void);
	~CSeaMaxLin(void);
	int Open(char *filename);
	int Close(void);

	int Read(slave_address_t slaveId, seaio_type_t type, 
			  address_loc_t starting_address, address_range_t range,
			  void *data);
	
	int Read(unsigned char *data, int length);
	
	int Write(slave_address_t slaveId, seaio_type_t type, 
			   address_loc_t starting_address,
			   address_range_t range, unsigned char *data);

	int Write(unsigned char *data, int length);
	
	int Ioctl(slave_address_t slaveId, IOCTL_t which, void *data);

	int set_intermessage_delay(int delay);
	
	int GetPIO(unsigned char* data);
	
	int SetPIO(unsigned char* data);
	
	int SetPIODirection(unsigned char* data);
	
	int GetPIODirection(unsigned char* data);
	
	HANDLE getCommHandle(void);

private:
	SeaMaxLin *SeaMaxPointer;
};

#endif //__cplusplus
#endif //SEAMAXLIN_H__