MCEuropeanEngine Vivado HLS

This is a subgroup of MCEuropeanEngine accelerated function with only synthesizable (Vivado HLS) functions/classes. More...

Collaboration diagram for MCEuropeanEngine Vivado HLS:

Files
file	mceuropeanengine.hpp
	The Role for a MCEuropeanEngine Example application (UDP or TCP)
file	mceuropeanengine.cpp
	The Role for a MCEuropeanEngine Example application (UDP or TCP)

Macros
#define	DEFAULT_TX_PORT   2718
#define	DEFAULT_RX_PORT   2718
#define	INPUT_PTR_WIDTH   64
#define	OUTPUT_PTR_WIDTH   64
#define	INSIZE   sizeof(varin)
#define	OUTSIZE   sizeof(DtUsed)*OUTDEP
#define	BITS_PER_10GBITETHRNET_AXI_PACKET   64
#define	BYTES_PER_10GBITETHRNET_AXI_PACKET   (BITS_PER_10GBITETHRNET_AXI_PACKET/8)
#define	IN_PACKETS   INSIZE/(BYTES_PER_10GBITETHRNET_AXI_PACKET)
#define	OUT_PACKETS   OUTSIZE/(BYTES_PER_10GBITETHRNET_AXI_PACKET)
#define	MIN_RX_LOOPS   IN_PACKETS*(BITS_PER_10GBITETHRNET_AXI_PACKET/INPUT_PTR_WIDTH)
#define	MIN_TX_LOOPS   OUT_PACKETS*(BITS_PER_10GBITETHRNET_AXI_PACKET/OUTPUT_PTR_WIDTH)
#define	WAIT_FOR_META   0
#define	WAIT_FOR_STREAM_PAIR   1
#define	PROCESSING_PACKET   2
#define	PROCESSING_WAIT   3
#define	MCEUROPEANENGINE_RETURN_RESULTS   4
#define	PacketFsmType   uint8_t

Functions
void	mceuropeanengine (ap_uint< 32 > *pi_rank, ap_uint< 32 > *pi_size, stream< NetworkWord > &siSHL_This_Data, stream< NetworkWord > &soTHIS_Shl_Data, stream< NetworkMetaStream > &siNrc_meta, stream< NetworkMetaStream > &soNrc_meta, ap_uint< 32 > *po_rx_ports)
	Main process of the MCEuropeanEngine Application directives. More...
void	storeWordToStruct (NetworkWord word, varin *instruct, unsigned int *processed_word_rx, unsigned int *struct_loaded)
	Store a word from ethernet to a local AXI stream. More...
void	pRXPath (stream< NetworkWord > &siSHL_This_Data, stream< NetworkMetaStream > &siNrc_meta, varin *instruct, NetworkMetaStream meta_tmp, unsigned int *processed_word_rx, unsigned int *struct_loaded)
	Receive Path - From SHELL to THIS. More...
void	pProcPath (stream< NetworkWord > &sRxpToTxp_Data, stream< NetworkMetaStream > &sRxtoTx_Meta, NetworkMetaStream meta_tmp, varin *instruct, double *out, unsigned int *processed_word_rx, unsigned int *processed_word_proc, unsigned int *struct_loaded)
	Processing Path - Main processing FSM for Vitis kernels. More...
void	pTXPath (stream< NetworkWord > &soTHIS_Shl_Data, stream< NetworkMetaStream > &soNrc_meta, stream< NetworkWord > &sRxpToTxp_Data, stream< NetworkMetaStream > &sRxtoTx_Meta, unsigned int *processed_word_tx, ap_uint< 32 > *pi_rank, ap_uint< 32 > *pi_size)
	Transmit Path - From THIS to SHELL. More...

Variables
uint8_t	enqueueFSM = 0
uint8_t	dequeueFSM = 1
uint8_t	MCEuropeanEngineFSM = 0

Detailed Description

This is a subgroup of MCEuropeanEngine accelerated function with only synthesizable (Vivado HLS) functions/classes.

This is a subgroup of MCEuropeanEngine accelerated function with only synthesizable (HLS) functions/classes.

Macro Definition Documentation

BITS_PER_10GBITETHRNET_AXI_PACKET

#define BITS_PER_10GBITETHRNET_AXI_PACKET   64

Definition at line 81 of file mceuropeanengine.hpp.

BYTES_PER_10GBITETHRNET_AXI_PACKET

#define BYTES_PER_10GBITETHRNET_AXI_PACKET   (BITS_PER_10GBITETHRNET_AXI_PACKET/8)

Definition at line 82 of file mceuropeanengine.hpp.

DEFAULT_RX_PORT

#define DEFAULT_RX_PORT   2718

Definition at line 64 of file mceuropeanengine.hpp.

DEFAULT_TX_PORT

#define DEFAULT_TX_PORT   2718

Definition at line 63 of file mceuropeanengine.hpp.

IN_PACKETS

#define IN_PACKETS   INSIZE/(BYTES_PER_10GBITETHRNET_AXI_PACKET)

Definition at line 84 of file mceuropeanengine.hpp.

INPUT_PTR_WIDTH

#define INPUT_PTR_WIDTH   64

Definition at line 71 of file mceuropeanengine.hpp.

INSIZE

#define INSIZE   sizeof(varin)

Definition at line 78 of file mceuropeanengine.hpp.

MCEUROPEANENGINE_RETURN_RESULTS

#define MCEUROPEANENGINE_RETURN_RESULTS   4

Definition at line 94 of file mceuropeanengine.hpp.

MIN_RX_LOOPS

#define MIN_RX_LOOPS   IN_PACKETS*(BITS_PER_10GBITETHRNET_AXI_PACKET/INPUT_PTR_WIDTH)

Definition at line 87 of file mceuropeanengine.hpp.

MIN_TX_LOOPS

#define MIN_TX_LOOPS   OUT_PACKETS*(BITS_PER_10GBITETHRNET_AXI_PACKET/OUTPUT_PTR_WIDTH)

Definition at line 88 of file mceuropeanengine.hpp.

OUT_PACKETS

#define OUT_PACKETS   OUTSIZE/(BYTES_PER_10GBITETHRNET_AXI_PACKET)

Definition at line 85 of file mceuropeanengine.hpp.

OUTPUT_PTR_WIDTH

#define OUTPUT_PTR_WIDTH   64

Definition at line 75 of file mceuropeanengine.hpp.

OUTSIZE

#define OUTSIZE   sizeof(DtUsed)*OUTDEP

Definition at line 79 of file mceuropeanengine.hpp.

PacketFsmType

#define PacketFsmType   uint8_t

Definition at line 96 of file mceuropeanengine.hpp.

PROCESSING_PACKET

#define PROCESSING_PACKET   2

Definition at line 92 of file mceuropeanengine.hpp.

PROCESSING_WAIT

#define PROCESSING_WAIT   3

Definition at line 93 of file mceuropeanengine.hpp.

WAIT_FOR_META

#define WAIT_FOR_META   0

Definition at line 90 of file mceuropeanengine.hpp.

WAIT_FOR_STREAM_PAIR

#define WAIT_FOR_STREAM_PAIR   1

Definition at line 91 of file mceuropeanengine.hpp.

Function Documentation

mceuropeanengine()

void mceuropeanengine	(	ap_uint< 32 > *	pi_rank,
		ap_uint< 32 > *	pi_size,
		stream< NetworkWord > &	siSHL_This_Data,
		stream< NetworkWord > &	soTHIS_Shl_Data,
		stream< NetworkMetaStream > &	siNrc_meta,
		stream< NetworkMetaStream > &	soNrc_meta,
		ap_uint< 32 > *	po_rx_ports
	)

Main process of the MCEuropeanEngine Application directives.

Deprecated:

This functions is using deprecated AXI stream interface

Returns

Nothing.

Definition at line 426 of file mceuropeanengine.cpp.

{
 
  //-- DIRECTIVES FOR THE BLOCK ---------------------------------------------
 //#pragma HLS INTERFACE ap_ctrl_none port=return
 
  //#pragma HLS INTERFACE ap_stable     port=piSHL_This_MmioEchoCtrl
 
#pragma HLS INTERFACE axis register both port=siSHL_This_Data
#pragma HLS INTERFACE axis register both port=soTHIS_Shl_Data
 
#pragma HLS INTERFACE axis register both port=siNrc_meta
#pragma HLS INTERFACE axis register both port=soNrc_meta
 
#pragma HLS INTERFACE ap_ovld register port=po_rx_ports name=poROL_NRC_Rx_ports
#pragma HLS INTERFACE ap_stable register port=pi_rank name=piFMC_ROL_rank
#pragma HLS INTERFACE ap_stable register port=pi_size name=piFMC_ROL_size
 
 
  //-- LOCAL VARIABLES ------------------------------------------------------
  static NetworkMetaStream  meta_tmp = NetworkMetaStream();
  static stream<NetworkWord>       sRxpToTxp_Data("sRxpToTxP_Data"); // FIXME: works even with no static
  static stream<NetworkMetaStream> sRxtoTx_Meta("sRxtoTx_Meta");
  static unsigned int processed_word_rx = 0;
  static unsigned int processed_word_tx = 0;
  static unsigned int processed_word_proc = 0;
  static unsigned int struct_loaded = 0;
  static varin instruct;
  static DtUsed out[OUTDEP];
  const int tot_transfers = TOT_TRANSFERS;
  *po_rx_ports = 0x1; //currently work only with default ports...
 
  
  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
#pragma HLS DATAFLOW 
#pragma HLS stream variable=sRxtoTx_Meta depth=tot_transfers 
//#pragma HLS stream variable=sRxpToTxp_Data depth=2048
#pragma HLS reset variable=enqueueFSM
#pragma HLS reset variable=dequeueFSM
#pragma HLS reset variable=MCEuropeanEngineFSM
#pragma HLS reset variable=processed_word_rx
#pragma HLS reset variable=processed_word_tx
#pragma HLS reset variable=processed_word_proc
#pragma HLS reset variable=struct_loaded
  
 
#ifdef USE_HLSLIB_DATAFLOW
  // Dataflow functions running in parallel
  HLSLIB_DATAFLOW_INIT();
  
  HLSLIB_DATAFLOW_FUNCTION(pRXPath, 
               siSHL_This_Data,
               siNrc_meta,
               &instruct,
               meta_tmp,
               &processed_word_rx,
               &struct_loaded);
  
  HLSLIB_DATAFLOW_FUNCTION(pProcPath,
               sRxpToTxp_Data,
               sRxtoTx_Meta,
               meta_tmp,
                   &instruct,
               out,
                   &processed_word_rx,
               &processed_word_proc,
                   &struct_loaded); 
 
  HLSLIB_DATAFLOW_FUNCTION(pTXPath,
               soTHIS_Shl_Data,
               soNrc_meta,
               sRxpToTxp_Data,
               sRxtoTx_Meta,
               &processed_word_tx,
               pi_rank,
               pi_size);
 
  HLSLIB_DATAFLOW_FINALIZE();
  
#else // !USE_HLSLIB_DATAFLOW
 pRXPath(
    siSHL_This_Data,
        siNrc_meta,
    &instruct,
        meta_tmp, 
        &processed_word_rx,
    &struct_loaded);
  
  
  pProcPath(sRxpToTxp_Data,
        sRxtoTx_Meta,
        meta_tmp,
        &instruct,
        out,
        &processed_word_rx,
        &processed_word_proc,
        &struct_loaded);  
 
  pTXPath(
        soTHIS_Shl_Data,
        soNrc_meta,
    sRxpToTxp_Data,
    sRxtoTx_Meta,
        &processed_word_tx,
        pi_rank,
        pi_size);
#endif // USE_HLSLIB_DATAFLOW
}

Here is the call graph for this function:

Here is the caller graph for this function:

pProcPath()

void pProcPath	(	stream< NetworkWord > &	sRxpToTxp_Data,
		stream< NetworkMetaStream > &	sRxtoTx_Meta,
		NetworkMetaStream	meta_tmp,
		varin *	instruct,
		double *	out,
		unsigned int *	processed_word_rx,
		unsigned int *	processed_word_proc,
		unsigned int *	struct_loaded
	)

Processing Path - Main processing FSM for Vitis kernels.

Parameters

[out]	sRxpToTxp_Data
[in]	img_in_axi_stream
[in]	img_out_axi_stream
[out]	processed_word_rx
[in]	struct_loaded

Returns

Nothing.

Definition at line 217 of file mceuropeanengine.cpp.

{
    //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
    //#pragma HLS DATAFLOW interval=1
    #pragma  HLS INLINE
    //-- LOCAL VARIABLES ------------------------------------------------------
    NetworkWord newWord;
    intToFloatUnion intToFloat;
    static bool finished = false;
    #pragma HLS reset variable=finished
    
  switch(MCEuropeanEngineFSM)
  {
    case WAIT_FOR_META: 
      printf("DEBUG in pProcPath: WAIT_FOR_META\n");
      *processed_word_proc = 0;
      finished = false;
      if ( (*struct_loaded) == 1 )
      {
        MCEuropeanEngineFSM = PROCESSING_PACKET;
    *processed_word_rx = 0;
    *struct_loaded = 0;
      }
      break;
 
    case PROCESSING_PACKET:
      printf("DEBUG in pProcPath: PROCESSING_PACKET\n");
      //if ( !img_in_axi_stream.empty() && !img_out_axi_stream.full() )
      {
    kernel_mc(instruct->loop_nm,
                           instruct->seed,
                           instruct->underlying,
                           instruct->volatility,
                           instruct->dividendYield,
                           instruct->riskFreeRate, // model parameter
                           instruct->timeLength,
                           instruct->strike,
                           instruct->optionType, // option parameter
                           out,
                           instruct->requiredTolerance,
                           instruct->requiredSamples,
                           instruct->timeSteps,
                           instruct->maxSamples,
               &finished);
    MCEuropeanEngineFSM = PROCESSING_WAIT;
      }
      break;
    case PROCESSING_WAIT:
      printf("DEBUG in pProcPath: PROCESSING_WAIT\n");
      {
    if (finished) {
      finished = false;
      MCEuropeanEngineFSM = MCEUROPEANENGINE_RETURN_RESULTS;
    }
      }
      break;
      
    case MCEUROPEANENGINE_RETURN_RESULTS:
      printf("DEBUG in pProcPath: MCEUROPEANENGINE_RETURN_RESULTS, *processed_word_proc=%u\n", *processed_word_proc);
    if ( !sRxpToTxp_Data.full() && !sRxtoTx_Meta.full()) {
      if (((((*processed_word_proc)+PACK_SIZE)*sizeof(DtUsed)) % PACK_SIZE == 0)){
        printf("DEBUG in pProcPath: New packet will be needed. Writting to sRxtoTx_Meta.\n");
        sRxtoTx_Meta.write(meta_tmp);
      }
      bool last;
      if ( (*processed_word_proc) == instruct->loop_nm-1 )  {
        last = 1;
        MCEuropeanEngineFSM = WAIT_FOR_META;
      }
      else {
        last = 0;
      }
      //TODO: find why Vitis kernel does not set keep and last by itself
      unsigned int keep = 255;
      intToFloat.f = out[(*processed_word_proc)++];
      newWord = NetworkWord((ap_uint<64>)intToFloat.i, keep, last); 
      sRxpToTxp_Data.write(newWord);
    }
      break;
  } // end switch
}

Here is the call graph for this function:

Here is the caller graph for this function:

pRXPath()

void pRXPath	(	stream< NetworkWord > &	siSHL_This_Data,
		stream< NetworkMetaStream > &	siNrc_meta,
		varin *	instruct,
		NetworkMetaStream	meta_tmp,
		unsigned int *	processed_word_rx,
		unsigned int *	struct_loaded
	)

Receive Path - From SHELL to THIS.

Parameters

[in]	siSHL_This_Data
[in]	siNrc_meta
[out]	sRxtoTx_Meta
[out]	img_in_axi_stream
[out]	meta_tmp
[out]	processed_word
[out]	struct_loaded

Returns

Nothing.

Definition at line 158 of file mceuropeanengine.cpp.

{
    //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
    //#pragma HLS DATAFLOW interval=1
     #pragma  HLS INLINE
    //-- LOCAL VARIABLES ------------------------------------------------------
    NetworkWord    netWord;
 
  switch(enqueueFSM)
  {
    case WAIT_FOR_META: 
      printf("DEBUG in pRXPath: enqueueFSM - WAIT_FOR_META, *processed_word_rx=%u\n",
         *processed_word_rx);
      if ( !siNrc_meta.empty())
      {
        meta_tmp = siNrc_meta.read();
        meta_tmp.tlast = 1; //just to be sure...
        enqueueFSM = PROCESSING_PACKET;
      }
      break;
 
    case PROCESSING_PACKET:
      printf("DEBUG in pRXPath: enqueueFSM - PROCESSING_PACKET, *processed_word_rx=%u\n",
         *processed_word_rx);
      if ( !siSHL_This_Data.empty() )
      {
        //-- Read incoming data chunk
        netWord = siSHL_This_Data.read();
    storeWordToStruct(netWord, instruct, processed_word_rx, struct_loaded);
        if(netWord.tlast == 1)
        {
          enqueueFSM = WAIT_FOR_META;
        }
      }
      break;
  }
 
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

pTXPath()

void pTXPath	(	stream< NetworkWord > &	soTHIS_Shl_Data,
		stream< NetworkMetaStream > &	soNrc_meta,
		stream< NetworkWord > &	sRxpToTxp_Data,
		stream< NetworkMetaStream > &	sRxtoTx_Meta,
		unsigned int *	processed_word_tx,
		ap_uint< 32 > *	pi_rank,
		ap_uint< 32 > *	pi_size
	)

Transmit Path - From THIS to SHELL.

Parameters

[out]	soTHIS_Shl_Data
[out]	soNrc_meta
[in]	sRxpToTxp_Data
[in]	sRxtoTx_Meta
[in]	pi_rank
[in]	pi_size

Returns

Nothing.

Definition at line 322 of file mceuropeanengine.cpp.

{
    //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
    //#pragma HLS DATAFLOW interval=1
    #pragma  HLS INLINE
    //-- LOCAL VARIABLES ------------------------------------------------------
    NetworkWord      netWordTx;
    NetworkMeta meta_in = NetworkMeta();
    NetworkMetaStream meta_out_stream = NetworkMetaStream();
   
  switch(dequeueFSM)
  {
    case WAIT_FOR_STREAM_PAIR:
      printf("DEBUG in pTXPath: dequeueFSM=%d - WAIT_FOR_STREAM_PAIR, *processed_word_tx=%u\n", 
         dequeueFSM, *processed_word_tx);
      //-- Forward incoming chunk to SHELL
      *processed_word_tx = 0;
      
      /*
      printf("!sRxpToTxp_Data.empty()=%d\n", !sRxpToTxp_Data.empty());
      printf("!sRxtoTx_Meta.empty()=%d\n", !sRxtoTx_Meta.empty());
      printf("!soTHIS_Shl_Data.full()=%d\n", !soTHIS_Shl_Data.full());
      printf("!soNrc_meta.full()=%d\n", !soNrc_meta.full());
      */
      
      if (( !sRxpToTxp_Data.empty() && !sRxtoTx_Meta.empty() 
          && !soTHIS_Shl_Data.full() &&  !soNrc_meta.full() )) 
      {
        netWordTx = sRxpToTxp_Data.read();
 
    // in case MTU=8 ensure tlast is set in WAIT_FOR_STREAM_PAIR and don't visit PROCESSING_PACKET
    if (PACK_SIZE == 8) 
    {
        netWordTx.tlast = 1;
    }
        soTHIS_Shl_Data.write(netWordTx);
 
        meta_in = sRxtoTx_Meta.read().tdata;
        
        meta_out_stream.tlast = 1;
        meta_out_stream.tkeep = 0xFF; //just to be sure
 
        meta_out_stream.tdata.dst_rank = (*pi_rank + 1) % *pi_size;
        //meta_out_stream.tdata.dst_port = DEFAULT_TX_PORT;
        meta_out_stream.tdata.src_rank = (NodeId) *pi_rank;
        //meta_out_stream.tdata.src_port = DEFAULT_RX_PORT;
        //printf("rank: %d; size: %d; \n", (int) *pi_rank, (int) *pi_size);
        //printf("meat_out.dst_rank: %d\n", (int) meta_out_stream.tdata.dst_rank);
        meta_out_stream.tdata.dst_port = meta_in.src_port;
        meta_out_stream.tdata.src_port = meta_in.dst_port;
    
    soNrc_meta.write(meta_out_stream);
    
    (*processed_word_tx)++;
    
        if(netWordTx.tlast != 1)
        {
          dequeueFSM = PROCESSING_PACKET;
        }
      }
      break;
 
    case PROCESSING_PACKET: 
      printf("DEBUG in pTXPath: dequeueFSM=%d - PROCESSING_PACKET, *processed_word_tx=%u\n", 
         dequeueFSM, *processed_word_tx);
      if( !sRxpToTxp_Data.empty() && !soTHIS_Shl_Data.full())
      {
        netWordTx = sRxpToTxp_Data.read();
    (*processed_word_tx)++;
 
    // This is a normal termination of the axi stream from vitis functions
    if(netWordTx.tlast == 1)
    {
      dequeueFSM = WAIT_FOR_STREAM_PAIR;
    }
    else if (((*processed_word_tx)*sizeof(DtUsed)) % PACK_SIZE == 0) 
    // This is our own termination based on the custom MTU we have set in PACK_SIZE.
    // TODO: We can map PACK_SIZE to a dynamically assigned value either through MMIO or header
    //       in order to have a functional bitstream for any MTU size
    {
        netWordTx.tlast = 1;
        dequeueFSM = WAIT_FOR_STREAM_PAIR;
    }
        soTHIS_Shl_Data.write(netWordTx);
      }
      break;
  }
}

Here is the caller graph for this function:

storeWordToStruct()

void storeWordToStruct	(	NetworkWord	word,
		varin *	instruct,
		unsigned int *	processed_word_rx,
		unsigned int *	struct_loaded
	)

Store a word from ethernet to a local AXI stream.

Returns

Nothing.

Definition at line 58 of file mceuropeanengine.cpp.

{   
  //#pragma HLS INLINE
  const unsigned int loop_cnt = (BITS_PER_10GBITETHRNET_AXI_PACKET/INPUT_PTR_WIDTH);
  for (unsigned int i=0; i<loop_cnt; i++) {
    printf("DEBUG: Checking: word.tkeep=%u >> %u = %u\n", word.tkeep.to_int(), i, (word.tkeep.to_int() >> i));
    if ((word.tkeep >> i) == 0) {
      printf("WARNING: value with tkeep=0 at i=%u\n", i);
      continue; 
    }
    intToFloatUnion intToFloat;
    intToFloat.i  = (DtUsedInt)(word.tdata >> i*loop_cnt);
    switch((*processed_word_rx)++)
      {
    case 0:
      if ((intToFloat.i == 0) || (intToFloat.i > OUTDEP)) {
        printf("WARNING Invalid instruct->loop_nm = %u. Will assign %u\n", (unsigned int)intToFloat.i, OUTDEP);
        instruct->loop_nm = OUTDEP;
      }
      else {
        instruct->loop_nm = intToFloat.i;
      }
      printf("DEBUG instruct->loop_nm = %u\n", (unsigned int)instruct->loop_nm);
      break;
    case 1:
      instruct->seed = intToFloat.i;
      printf("DEBUG instruct->seed = %u\n", (unsigned int)instruct->seed);
      break;  
    case 2:
      instruct->underlying = intToFloat.f;
      printf("DEBUG instruct->underlying = %f\n", instruct->underlying);
      break;
    case 3:
      instruct->volatility = intToFloat.f;
      printf("DEBUG instruct->volatility = %f\n", instruct->volatility);
      break;
    case 4:
      instruct->dividendYield = intToFloat.f;
      printf("DEBUG instruct->dividendYield = %f\n", instruct->dividendYield);
      break;
    case 5:
      instruct->riskFreeRate = intToFloat.f;
      printf("DEBUG instruct->riskFreeRate = %f\n", instruct->riskFreeRate);
      break;
    case 6:
      instruct->timeLength = intToFloat.f;
      printf("DEBUG instruct->timeLength = %f\n", instruct->timeLength);
      break;  
    case 7:
      instruct->strike = intToFloat.f;
      printf("DEBUG instruct->strike = %f\n", instruct->strike);
      break;
    case 8:
      instruct->optionType = intToFloat.i;
      printf("DEBUG instruct->optionType = %u\n", (unsigned int)instruct->optionType);
      break;
    case 9:
      instruct->requiredTolerance = intToFloat.f;
      printf("DEBUG instruct->requiredTolerance = %f\n", instruct->requiredTolerance);
      break;
    case 10:
      instruct->requiredSamples = intToFloat.i;
      printf("DEBUG instruct->requiredSamples = %u\n", (unsigned int)instruct->requiredSamples);
      break;
    case 11:
      instruct->timeSteps = intToFloat.i;
      printf("DEBUG instruct->timeSteps = %u\n", (unsigned int)instruct->timeSteps);
      break;  
    case 12:
      instruct->maxSamples = intToFloat.i;
      printf("DEBUG instruct->maxSamples = %u\n", (unsigned int)instruct->maxSamples);
      *struct_loaded = 1;
      printf("DEBUG in storeWordToStruct: WARNING - you've loaded the struct. Will put *struct_loaded = 1.\n");
      break;
    default:
      break;
      }
  }
 
}

Here is the caller graph for this function:

Variable Documentation

dequeueFSM

uint8_t dequeueFSM = 1

Definition at line 50 of file mceuropeanengine.cpp.

enqueueFSM

uint8_t enqueueFSM = 0

Definition at line 49 of file mceuropeanengine.cpp.

MCEuropeanEngineFSM

uint8_t MCEuropeanEngineFSM = 0

Definition at line 51 of file mceuropeanengine.cpp.