# File    : rtlinux.tmf  
# Abstract:
#	Real-Time Workshop template makefile for building a RTLinux
#	real-time version of Simulink model using generated C code.
#
# 	This makefile attempts to conform to the guidelines specified in the
# 	IEEE Std 1003.2-1992 (POSIX) standard. It is designed to be used
#       with GNU Make which is located in matlabroot/rtw/bin.
#
# 	Note that this template is automatically customized by the Real-Time
#	Workshop build procedure to create "<model>.mk"
#
#       The following defines can be used to modify the behavior of the
#	build:
#	  OPT_OPTS       - Optimization options. Default is -O. To enable 
#                          debugging specify as OPT_OPTS=-g. 
#                          Because of optimization problems in IBM_RS, 
#                          default is no-optimization. 
#	  OPTS           - User specific compile options.
#	  USER_SRCS      - Additional user sources, such as files needed by
#			   S-functions.
#	  USER_INCLUDES  - Additional include paths
#			   (i.e. USER_INCLUDES="-Iwhere-ever -Iwhere-ever2")
#
#       This template makefile is designed to be used with a system target
#       file that contains 'rtwgensettings.BuildDirSuffix' see grt.tlc

#------------------------ Macros read by make_rtw ------------------------------
#
# The following macros are read by the Real-Time Workshop build procedure:
#
#  MAKECMD         - This is the command used to invoke the make utility
#  HOST            - What platform this template makefile is targeted for
#                    (i.e. PC or UNIX)
#  BUILD           - Invoke make from the Real-Time Workshop build procedure
#                    (yes/no)?
#  SYS_TARGET_FILE - Name of system target file.

MAKECMD         = make
HOST            = UNIX
BUILD           = yes
SYS_TARGET_FILE = rtlinux.tlc

#---------------------- Tokens expanded by make_rtw ----------------------------
#
# The following tokens, when wrapped with "|>" and "|<" are expanded by the
# Real-Time Workshop build procedure.
#
#  MODEL_NAME          - Name of the Simulink block diagram
#  MODEL_MODULES       - Any additional generated source modules
#  MAKEFILE_NAME       - Name of makefile created from template makefile <model>.mk
#  MATLAB_ROOT         - Path to were MATLAB is installed.
#  S_FUNCTIONS         - List of S-functions.
#  S_FUNCTIONS_LIB     - List of S-functions libraries to link. 
#  SOLVER              - Solver source file name
#  NUMST               - Number of sample times
#  TID01EQ             - yes (1) or no (0): Are sampling rates of continuous task
#                        (tid=0) and 1st discrete task equal.
#  NCSTATES            - Number of continuous states
#  COMPUTER            - Computer type. See the MATLAB computer command.
#  BUILDARGS           - Options passed in at the command line.
#  MULTITASKING        - yes (1) or no (0): Is solver mode multitasking
#  EXT_MODE            - yes (1) or no (0): Build for external mode
#  TMW_EXTMODE_TESTING - yes (1) or no (0): Build ext_test.c for external mode
#                        testing.
#  PORT                - Port number of the TCP/IP communication.
#                        Valid range 256 to 65535.
#  VERBOSE             - Enables the display of messages, warnings and error.
#  WAIT_START          - ST-RTL waits for the START message to start the real-time process.
#  FINAL_TIME          - The Final Time must be a positive, real value or inf.
#  RT_MONITORING       - Enables an algorithm to improve real-time monitoring.
#                        It only works in isolated LAN. Do not select this option
#                        if you intend to connect to the RTLinux workstation using a WAN.
#                        The algorithm consists of transmitting only data that fits
#                        within the available hardware-network infrastructure.
#                        Data is therefore discarded.
#  BLOCK_AD_CONV       - If enabled, it polls the busy flag until the A/D conversion is finished.
#                        This method is blocking and consumes all the CPU resource while waiting.
#                        If not enabled (recommended option), the non-blocking function usleep() 
#                        is used. It gives up the CPU but takes longer due to scheduling. Consequently,
#                        the cycle time increases and the maximum sample rate possible decreases.
#                        Polling is more accurate but wastes more CPU resources.



MODEL                = |>MODEL_NAME<|
MODULES              = |>MODEL_MODULES<|
MAKEFILE             = |>MAKEFILE_NAME<|
MATLAB_ROOT          = /STRTL_M6.5
S_FUNCTIONS          = |>S_FUNCTIONS<|
S_FUNCTIONS_LIB      = |>S_FUNCTIONS_LIB<|
SOLVER               = |>SOLVER<|
NUMST                = |>NUMST<|
TID01EQ              = |>TID01EQ<|
NCSTATES             = |>NCSTATES<|
COMPUTER             = LNX86
BUILDARGS            = |>BUILDARGS<|
MULTITASKING         = |>MULTITASKING<|
EXT_MODE             = |>EXT_MODE<|
TMW_EXTMODE_TESTING  = |>TMW_EXTMODE_TESTING<|
PORT                 = |>PORT<|
VERBOSE              = |>VERBOSE<|
WAIT_START           = |>WAIT_START<|
FINAL_TIME           = |>FINAL_TIME<|
RT_MONITORING        = |>RT_MONITORING<|
BLOCK_AD_CONV        = |>BLOCK_AD_CONV<|


#--------------------------- Tool Specifications -------------------------------

include $(MATLAB_ROOT)/rtw/c/tools/unixtools.mk


#------------------------------ Include Path -----------------------------------

# RTLinux include paths
RTL_INCLUDES = $(shell rtl-config --rtinclude)

MATLAB_INCLUDES = \
	-I$(MATLAB_ROOT)/simulink/include \
	-I$(MATLAB_ROOT)/rtw/c/src \
	-I$(MATLAB_ROOT)/rtw/c/libsrc \
	-I$(MATLAB_ROOT)/rtw/c/servotogo \
	-I. 

# Additional file include paths
ADD_INCLUDES = \
|>START_EXPAND_INCLUDES<|	-I|>EXPAND_DIR_NAME<| \
|>END_EXPAND_INCLUDES<|


INCLUDES = -I. $(MATLAB_INCLUDES)  $(ADD_INCLUDES) $(RTL_INCLUDES) \
	$(USER_INCLUDES) $(INSTRUMENT_INCLUDES)


#----------------------------- External mode -----------------------------------

ifeq ($(EXT_MODE),1)
  RTL_EXT_SRCS = ext_svr_rtl.c updown.c ext_work.c  
  US_EXT_SRCS = $(MATLAB_ROOT)/rtw/c/src/ext_svr_us.c \
		$(MATLAB_ROOT)/rtw/c/src/ext_svr_transport.c \
		$(MATLAB_ROOT)/rtw/c/src/us_main.c 

  EXT_CC_OPTS = -DEXT_MODE -D$(COMPUTER) -DPORT=$(PORT) -DWAIT_START_MODEL=$(WAIT_START)

  # Enable real-time monitoring?
  ifeq ($(RT_MONITORING),1)
     EXT_CC_OPTS += -DRT_MONITORING
  endif

  EXT_LIB     =

  ifeq ($(COMPUTER),SOL2)
    EXT_LIB = -lsocket -lnsl
  endif
else
  US_EXT_SRCS = $(MATLAB_ROOT)/rtw/c/src/us_main.c
endif

# User-define parameters are translated into precompiler macros
# The following list needs to be set even when External Mode is not selected.
# We put it here for convenience only.

# Run forever FT = inf?
ifeq ($(FINAL_TIME),inf)
  FINAL_TIME = -1.0
endif
ifeq ($(FINAL_TIME),"inf")
  FINAL_TIME = -1.0
endif
EXT_CC_OPTS += -DFT=$(FINAL_TIME)

# Enable verbosity?
ifeq ($(VERBOSE),1)
   EXT_CC_OPTS += -DVERBOSE
endif

# Blocking wait for A/D conversion?
ifeq ($(BLOCK_AD_CONV),1)
   EXT_CC_OPTS += -DBLCK_WAIT
endif


#----------------------------- Real-Time Model ---------------------------------

RTM_CC_OPTS = -DUSE_RTMODEL

#-------------------------------- C Flags --------------------------------------

# RTLinux c flags
RTL_OPTS = $(shell rtl-config --cflags) 

# Optimization Options
ifndef OPT_OPTS
OPT_OPTS = $(DEFAULT_OPT_OPTS)
endif

# General User Options
OPTS =

# Compiler options, etc:
CC_OPTS = $(OPT_OPTS) $(OPTS) $(ANSI_OPTS) $(EXT_CC_OPTS) $(RTM_CC_OPTS)

CPP_REQ_DEFINES = -DMODEL=$(MODEL) -DRT -DNUMST=$(NUMST) \
                  -DTID01EQ=$(TID01EQ) -DNCSTATES=$(NCSTATES) -DUNIX \
                  -DMT=$(MULTITASKING)

CFLAGS = $(CC_OPTS) $(CPP_REQ_DEFINES) $(RTL_OPTS) $(INCLUDES)

LDFLAGS = -r -static 

#-------------------------- Additional Libraries ------------------------------

SYSLIBS = $(EXT_LIB) -lm

LD = ld

|>START_PRECOMP_LIBRARIES<|
#ifeq ($(OPT_OPTS),$(DEFAULT_OPT_OPTS))
#LIBS += |>EXPAND_LIBRARY_LOCATION<|/|>EXPAND_LIBRARY_NAME<|_std.a
#else
LIBS += |>EXPAND_LIBRARY_NAME<|.a
#endif
|>END_PRECOMP_LIBRARIES<| |>START_EXPAND_LIBRARIES<|
LIBS += |>EXPAND_LIBRARY_NAME<|.a |>END_EXPAND_LIBRARIES<|
LIBS += $(S_FUNCTIONS_LIB) $(INSTRUMENT_LIBS)


RTWLIB  = rtwlib.a

LIB_MATH = -L/usr/lib -lm

LIBS    += $(LIB_MATH)


#----------------------------- Source Files ------------------------------------

DAC = ciodas08jrao.c
UTILS = drv_utils.c
REQ_SRCS  = $(MODEL).c $(MODULES) $(DAC) $(UTILS) krnl_main.c grt_main.c rt_sim.c \
            rt_nonfinite.c $(RTL_EXT_SRCS)

USER_SRCS =

USER_OBJS       = $(USER_SRCS:.c=.o)
LOCAL_USER_OBJS = $(notdir $(USER_OBJS))

SRCS      = $(REQ_SRCS) $(S_FUNCTIONS) $(SOLVER)
OBJS      = $(SRCS:.c=.o) $(USER_OBJS)
LINK_OBJS = $(SRCS:.c=.o) $(LOCAL_USER_OBJS)

PROGRAM = $(MODEL)

#------------- Test Compile using gcc -Wall to look for warnings ---------------
#
# DO_GCC_TEST=1 runs gcc with compiler warning flags on all the source files
# used in this build. This includes the generated code, and any user source
# files needed for the build and placed in this directory.
#
# WARN_ON_GLNX=1 runs the linux compiler with warnings flags. On hand-written
# code we use the max amount of flags availabe while on the generated code, a
# few less.
#
# See rtw/c/tools/unixtools.mk for the definition of GCC_WARN_OPTS
GCC_TEST_CMD  := echo
GCC_TEST_OUT  := > /dev/null
ifeq ($(DO_GCC_TEST), 1)
  GCC_TEST := gcc -c -o /dev/null $(GCC_WARN_OPTS_MAX) $(CPP_REQ_DEFINES) \
                                     $(INCLUDES)
  GCC_TEST_CMD := echo; echo "\#\#\# GCC_TEST $(GCC_TEST) $<"; $(GCC_TEST)
  GCC_TEST_OUT := ; echo
endif

GCC_WALL_FLAG     :=
GCC_WALL_FLAG_MAX :=
ifeq ($(COMPUTER), GLNX86)
ifeq ($(WARN_ON_GLNX), 1)
  GCC_WALL_FLAG     := $(GCC_WARN_OPTS)
  GCC_WALL_FLAG_MAX := $(GCC_WARN_OPTS_MAX)
endif
endif


#----------------------------- Lint (sol2 only) --------------------------------

LINT_SRCS = $(MATLAB_ROOT)/rtw/c/grt/grt_main.c \
	    $(MATLAB_ROOT)/rtw/c/src/rt_sim.c \

ifneq ($(SOLVER), )
  LINT_SRCS += $(MATLAB_ROOT)/rtw/c/src/$(SOLVER)
endif
ifneq ($(EXT_SRC), )
  LINT_SRCS += $(MATLAB_ROOT)/rtw/c/src/$(EXT_SRC)
endif
LINT_SRCS += $(MODEL).c $(MODULES) $(USER_SRCS) $(S_FUNCTIONS)
LINTOPTSFILE = $(MODEL).lintopts

LINT_ERROFF1 = E_NAME_DEF_NOT_USED2,E_NAME_DECL_NOT_USED_DEF2
LINT_ERROFF2 = $(LINT_ERROFF1),E_FUNC_ARG_UNUSED
LINT_ERROFF  = $(LINT_ERROFF2),E_INDISTING_FROM_TRUNC2,E_NAME_USED_NOT_DEF2

#--------------------------------- Rules ---------------------------------------

.PHONY: all load unload
all: $(PROGRAM) $(PROGRAM)_rtl.o load

$(PROGRAM)_rtl.o : $(OBJS) $(RTWLIB)
	ld $(LDFLAGS) -o $@ $(LINK_OBJS) $(RTWLIB) $(CUSTLIB) $(LIBS)
	@echo "### Created module: $(PROGRAM)_rtl.o"

$(PROGRAM): $(US_EXT_SRCS) $(MATLAB_ROOT)/rtw/c/src/common.h
	$(CC) $(MATLAB_INCLUDES) $(CPP_REQ_DEFINES) $(CC_OPTS) -O2 -w -o $@ $(US_EXT_SRCS)
	@echo "### Created executable: $(MODEL)"

%.o : %.c
	@$(GCC_TEST_CMD) $< $(GCC_TEST_OUT)
	$(CC) -c -o $(@F) $(CFLAGS) $(GCC_WALL_FLAG) $<

%.o : $(MATLAB_ROOT)/rtw/c/grt/%.c
	@$(GCC_TEST_CMD) $< $(GCC_TEST_OUT)
	$(CC) -c $(CFLAGS) $(GCC_WALL_FLAG_MAX) $<

%.o : $(MATLAB_ROOT)/rtw/c/src/%.c
	@$(GCC_TEST_CMD) $< $(GCC_TEST_OUT)
	$(CC) -c $(CFLAGS) $(GCC_WALL_FLAG_MAX) $<

%.o : $(MATLAB_ROOT)/rtw/c/libsrc/%.c
	@$(GCC_TEST_CMD) $< $(GCC_TEST_OUT)
	$(CC) -c $(CFLAGS) $(GCC_WALL_FLAG_MAX) $<

%.o : $(MATLAB_ROOT)/rtw/c/servotogo/%.c
	@$(GCC_TEST_CMD) $< $(GCC_TEST_OUT)
	$(CC) -c $(CFLAGS) $(GCC_WALL_FLAG_MAX) $<

%.o : $(MATLAB_ROOT)/rtw/c/libsrc/%.cpp
	@$(GCC_TEST_CMD) $< $(GCC_TEST_OUT)
	$(CPP) -c $(CFLAGS) $<

%.o : $(MATLAB_ROOT)/simulink/src/%.c
	@$(GCC_TEST_CMD) $< $(GCC_TEST_OUT)
	$(CC) -c $(CFLAGS) $(GCC_WALL_FLAG_MAX) $<

%.o : $(MATLAB_ROOT)/simulink/src/%.cpp
	@$(GCC_TEST_CMD) $< $(GCC_TEST_OUT)
	$(CPP) -c $(CFLAGS) $<

%.o : ../%.c
	@$(GCC_TEST_CMD) $< $(GCC_TEST_OUT)
	$(CC) -c $(CFLAGS) $(GCC_WALL_FLAG) $<

%.o : ../%.cpp
	@$(GCC_TEST_CMD) $< $(GCC_TEST_OUT)
	$(CPP) -c $(CFLAGS) $<

load:
	@rtlinux start $(PROGRAM)_rtl.o
	@./$(PROGRAM)

unload:
	@echo "### Unloading modules from the kernel... "
	@rtlinux stop $(PROGRAM)_rtl


#------------------------------- Libraries -------------------------------------

|>START_EXPAND_LIBRARIES<|MODULES_|>EXPAND_LIBRARY_NAME<| = \
|>START_EXPAND_MODULES<|	|>EXPAND_MODULE_NAME<|.o \
|>END_EXPAND_MODULES<|

|>EXPAND_LIBRARY_NAME<|.a : $(MAKEFILE) rtw_proj.tmw $(MODULES_|>EXPAND_LIBRARY_NAME<|)
	@echo "### Creating $@ "
	ar r $@ $(MODULES_|>EXPAND_LIBRARY_NAME<|)
	@echo "### Created $@"

|>END_EXPAND_LIBRARIES<|

|>START_PRECOMP_LIBRARIES<|MODULES_|>EXPAND_LIBRARY_NAME<| = \
|>START_EXPAND_MODULES<|	|>EXPAND_MODULE_NAME<|.o \
|>END_EXPAND_MODULES<|

|>EXPAND_LIBRARY_NAME<|.a : $(MAKEFILE) rtw_proj.tmw $(MODULES_|>EXPAND_LIBRARY_NAME<|)
	@echo "### Creating $@ "
	ar r $@ $(MODULES_|>EXPAND_LIBRARY_NAME<|)
	@echo "### Created $@"

|>END_PRECOMP_LIBRARIES<|

#----------------------------- Dependencies ------------------------------------

$(OBJS) : $(MAKEFILE) rtw_proj.tmw

#--------- Miscellaneous rules to purge, clean and lint (sol2 only) ------------

purge : clean
	@echo "### Deleting the generated source code for $(MODEL)"
	@\rm -f $(MODEL).c $(MODEL).h $(MODEL)_types.h $(MODEL)_data.c \
	        $(MODEL)_private.h $(MODEL).rtw $(MODULES) rtw_proj.tmw $(MAKEFILE)

clean :
	@echo "### Deleting the objects and $(PROGRAM)"
	@\rm -f $(LINK_OBJS) $(PROGRAM)

lint  : rtwlib.ln
	@lint -errchk -errhdr=%user -errtags=yes -F -L. -lrtwlib -x -Xc \
	      -erroff=$(LINT_ERROFF) \
	      -D_POSIX_C_SOURCE $(CFLAGS) $(LINT_SRCS)
	@\rm -f $(LINTOPTSFILE)
	@echo
	@echo "### Created lint output only, no executable"
	@echo

rtwlib.ln : $(MAKEFILE) rtw_proj.tmw
	@echo
	@echo "### Linting ..."
	@echo
	@\rm -f llib-lrtwlib.ln $(LINTOPTSFILE)
	@echo "-dirout=. -errchk -errhdr=%user " >> $(LINTOPTSFILE)
	@echo "-errtags -F -ortwlib -x -Xc " >> $(LINTOPTSFILE)
	@echo "-erroff=$(LINT_ERROFF) " >> $(LINTOPTSFILE)
	@echo "-D_POSIX_C_SOURCE $(CFLAGS) " >> $(LINTOPTSFILE)
	@for file in $(MATLAB_ROOT)/rtw/c/libsrc/*.c; do \
	  echo "$$file " >> $(LINTOPTSFILE); \
	done
	lint -flagsrc=$(LINTOPTSFILE)

# EOF: rtlinux.tmf