/*
 *  mpsConstantsAndTypes.h
 *
 *  Created by Stephen Norum.
 *  Copyright 2008 Stanford Linear Accelerator Center. All rights reserved.
 *
 */


#ifndef MPSCONTANTSANDTYPES_H
#define MPSCONTANTSANDTYPES_H
#ifdef __cplusplus
extern "C" {
#endif



#if 0
#pragma mark -
#pragma mark Link Nodes
#endif
/****************************************************************************************
 * Link Nodes
 ***************************************************************************************/

enum {
    MPSMaxPathLength = 1024,
    MPSMaxTruthTableCount = 2048
};


enum MPSCommonLinkNodeIds {
    MPSLinkNodeIdMin     = 0x02,    /*   2 */
    MPSLinkNodeIdMax     = 0xFD,    /* 253 */
    MPSLinkNodeIdInvalid = 0xFE,    /* 254 */
};


enum MPSCommonLinkNodeConfiguration {    
    /* Card Id Offsets */
    MPSLinkNodeCardIdOffsetInput   =  0,    /* Digital Input Card Slot 1-6  ->  Card ID 1-6  */
    MPSLinkNodeCardIdOffsetVirtual =  6,    /* Virtual Card Slot 1-2        ->  Card ID 7-8  */
    MPSLinkNodeCardIdOffsetBlm     =  8,    /* BLM Card Slots 1-8           ->  Card ID 9-16 */
    MPSLinkNodeCardIdOffsetPic     =  8,    /* PIC Card Slots 1-32          ->  Card ID 9-40 */
    
    /* Min and Max Card IDs */
    MPSLinkNodeCardIdMin           =  1,
    MPSLinkNodeCardIdMax           = 40,

    /* Each card has 16 channels, channels 1-16. */
    MPSLinkNodeChannelMin          =  1,
    MPSLinkNodeChannelMax          = 16
};


enum MPSCommonLinkNodeLimits {
    MPSLinkNodeMaxChannelsPerCard     = MPSLinkNodeChannelMax - MPSLinkNodeChannelMin + 1,
    MPSLinkNodeMaxCardsPerLinkNode    = MPSLinkNodeCardIdMax  - MPSLinkNodeCardIdMin  + 1,
    MPSLinkNodeMaxChannelsPerLinkNode = MPSLinkNodeMaxChannelsPerCard * MPSLinkNodeMaxCardsPerLinkNode,
    MPSLinkNodeMaxCount               = 256
};


enum MPSCommonLinkNodeTypes {
    MPSLinkNodeTypeMitigationControl = 0,
    MPSLinkNodeTypeBlm               = 1,
    MPSLinkNodeTypeBykik             = 2,
    MPSLinkNodeTypeMpgControl        = 3,
    MPSLinkNodeTypePic               = 4
};
typedef enum MPSCommonLinkNodeTypes MPSLinkNodeType;




struct mpsLinkNodeChannelStruct {
    unsigned int faultNumber;
};
typedef struct mpsLinkNodeChannelStruct mpsLinkNodeChannel;


struct mpsLinkNodeCardStruct {
    mpsLinkNodeChannel channel[MPSLinkNodeMaxChannelsPerCard];
};
typedef struct mpsLinkNodeCardStruct mpsLinkNodeCard;


struct mpsLinkNodeStruct {
    unsigned int    number;

    unsigned int    faultNumberFirst;
    unsigned int    faultNumberLast;
    unsigned int    faultNumberCount;
    
    char            isActive;
    MPSLinkNodeType type;
    
    mpsLinkNodeCard card[MPSLinkNodeMaxCardsPerLinkNode];
};
typedef struct mpsLinkNodeStruct mpsLinkNode;


#if 0
#pragma mark -
#pragma mark Beam Rates
#endif

/****************************************************************************************
 * Beam Rates
 ***************************************************************************************/

/* Note that order is important.  Rates can only become lower values during algorithm processing. */
enum MPSBeamRates {
    MPSRateInvalid            =  0,
    MPSRate0Hz                =  1,
    /* Previously used 2 and 3 for single shot and burst */
    MPSRate1Hz                =  4,
    MPSRate10Hz               =  5,
    MPSRate30Hz               =  6,
    MPSRate60Hz               =  7,
    MPSRate120Hz              =  8,
    MPSRateUnknown            =  9,
    
    MPSRateSingleShot         = 10,
    MPSRateBurstMode          = 11,
    MPSRateBurstModeNotActive = 12,
    
    MPSNumberOfBeamRates      = 13,
    MPSRateBurstInvalid       = 14
};
typedef enum MPSBeamRates MPSBeamRate;

const char *MPSBeamRateString(MPSBeamRate rate);









#if 0
#pragma mark -
#pragma mark Beam Destinations
#endif

/****************************************************************************************
 * Beam Destinations
 ***************************************************************************************/

enum MPSBeamDestinations {
    MPSDestinationInvalid                =  0,
    MPSDestinationPockelsCell            =  1,
    MPSDestinationMechanicalShutter      =  2,
    MPSDestinationLaserHeaterShutter     =  3,
    MPSDestinationGunSpectrometer        =  4,
    MPSDestinationYagBl211               =  5,
    MPSDestinationStraightAheadBeamDump  =  6,
    MPSDestinationTd11                   =  7,
    MPSDestinationD2                     =  8,
    MPSDestination52Sl2                  =  9,
    MPSDestinationBykikDump              = 10,
    MPSDestinationTdUnd                  = 11,
    MPSDestinationMainDump               = 12,
    MPSDestinationPhotonShutter          = 13,
    MPSDestinationExperiment             = 14,
    MPSNumberOfDestinations              = 15
};
typedef enum MPSBeamDestinations MPSBeamDestination;

const char *MPSBeamDestinationString(MPSBeamDestination destination);











#if 0
#pragma mark -
#pragma mark Mitigation Devices
#endif

/****************************************************************************************
 * Mitigation Devices
 ***************************************************************************************/

enum MPSMitigationDevices {
	MPSMitigationDevicePockelsCell        =  0,
	MPSMitigationDeviceMechanicalShutter  =  1,
	MPSMitigationDeviceBykik              =  2,
	MPSMitigationDeviceFuture             =  3,
	MPSMitigationDeviceLaserHeaterShutter =  3,
    MPSMitigationDeviceCount              =  4,
    MPSMitigationDeviceAll                = 99,
    MPSMitigationDeviceInvalid            = 98,
};
typedef enum MPSMitigationDevices MPSMitigationDevice;

const char *MPSMitigationDeviceString(MPSMitigationDevice device);


#if 0
#pragma mark -
#pragma mark Truth Table States
#endif

enum MPSTruthTableStates {
    MPSTruthTableIgnoreNotIgnoring = 200,
    MPSTruthTableIgnoreIgnoring    = 201,
    MPSTruthTableStateIgnored      = 202,
    MPSTruthTableStateInvalid      = 203
};



#if 0
#pragma mark -
#pragma mark Events
#endif

/****************************************************************************************
 * Events
 ***************************************************************************************/

enum MPSEPICSEvents {
    MPSEPICSEventBypassListChanged = 101,
    MPSEPICSEventAlgorithmDataChanged = 102,
    MPSEPICSEventBurstReadyStatusChanged = 103
};





#if 0
#pragma mark -
#pragma mark Rate and State Control
#endif

/****************************************************************************************
 * Rate and State Control
 ***************************************************************************************/

struct machineStateBuffersStruct
{
    /* Buffer pointers */
    char  *deviceState;
    char  *latchedDeviceState;
    char  *bypassValue;
    char  *bypassActive;
    char  *truthTableState;
    char  *newTruthTableState;
        
    /* Buffer sizes */
    unsigned int deviceStateSize;
    unsigned int latchedDeviceStateSize;
    unsigned int bypassValueSize;
    unsigned int bypassActiveSize;
    unsigned int truthTableStateSize;
    unsigned int newTruthTableStateSize;
};
typedef struct machineStateBuffersStruct MPSMachineStateBuffers;



#ifdef __cplusplus
}
#endif
#endif