1992 Layout Page

2006 Layout Page

2009 Layout Page

P&LE Postcards by Howard Fogg 

Plasticville Buildings

Portable Layout Page

Train Clubs

Bing Track

Remote Train Control Program

YouTube Channel

OOK Radio Support

Technical Videos

3D Prints for my Layout

More RTC Videos

ADPCM - Playing clips from .mth sound files

P&LE McKees Rocks Locomotive Shop
3D Printer Project

White Tower Restaurant
3D Printer Project

RFID Train Detection

RFID Tag Programmer using PN532

RTC Control Language - Scripting

More RFID Tag Videos

RTC Control Language - Signaling

Lua (/ˈluːə/ LOO-ə; from Portuguese: lua [ˈlu.(w)ɐ] meaning moon)^[a] is a lightweight, multi-paradigm programming language designed primarily for embedded use in applications.^[2] Lua is cross-platform, since the interpreter is written in ANSI C,^[3] and has a relatively simple C API.^[4]

Lua was originally designed in 1993 as a language for extending software applications to meet the increasing demand for customization at the time. It provided the basic facilities of most procedural programming languages, but more complicated or domain-specific features were not included; rather, it included mechanisms for extending the language, allowing programmers to implement such features. As Lua was intended to be a general embeddable extension language, the designers of Lua focused on improving its speed, portability, extensibility, and ease-of-use in development.

Lua was created in 1993 by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, and Waldemar Celes, members of the Computer Graphics Technology Group (Tecgraf) at the Pontifical Catholic University of Rio de Janeiro, in Brazil. 

Lua is a powerful, efficient, lightweight, embeddable scripting language. It supports procedural programming, object-oriented programming, functional programming, data-driven programming, and data description.

Lua combines simple procedural syntax with powerful data description constructs based on associative arrays and extensible semantics. Lua is dynamically typed, runs by interpreting bytecode with a register-based virtual machine, and has automatic memory management with incremental garbage collection, making it ideal for configuration, scripting, and rapid prototyping.

• Detector - the detector number as coded into the Arduino sketch. Starts at 1. The RFID system can support up to 127 detectors.
• Reader - the reader number, starts at 0. Each detector can support up to 6 readers.
• EngineNo - the engine number as coded into the tag. Zero if the tag is not on an engine.
• TagLocation - the location of the tag as coded into the tag. A number. Look at the "defines.lua" file for values.
• CarModel - the car model or engine model as coded into the tag. A number. Look at the "defines.lua" file for values.
• Railroad - the railroad name as coded into the tag. A Number, Look at the "defines.lua" file for values.
• CarNumber - the 6 character car or engine number as coded into the tag. A string which can contain number or letters. Leading and trailing spaces have been removed.
• TagPacket - the entire packet of information returned by the detector. 4 bytes of UID followed by 16 bytes of Block 4 data coded into the tag. Look at the RTC_NFC.h file for values.

-- Semicolons are not required in Lua code
-- Do Nothing Loop Test
title = "Do Nothing Loop Test"
--
-- This test runs a simple "do nothing" script
--
require("defines");
require("functions");

local MyEngineNo, MyTIUNo;

-- Counter Labels
Counter01Label = "Do Nothing";

--[[---------------------------------------------------------------------------------------]]
function setup(Engine)
	-- the setup() function is called once at the beginning of the run
	MyEngineNo = Engine;	-- Engine number selected on the RTC Main window
	MyTIUNo = GetTIUNo(MyEngineNo);	-- TIU associated with MyEngineNo
	print("setup(): Engine Number " .. MyEngineNo .. " TIU Number " .. MyTIUNo .. " Debug " .. Debug());
	-- Do nothing	
	return true;		-- false=setup failed, true=setup succeeded
	end
--[[---------------------------------------------------------------------------------------]]
function loop()
	-- The loop() function is repeatedly called
	-- Always call Sleep() at least once in this function if it returns true
	print(string.format("loop %.2f", RunTime()));
	Sleep(10);
	-- Do nothing	
	return true;	-- false=do not loop, true=continue to loop
	end
--[[---------------------------------------------------------------------------------------]]
function cleanup()
	-- the cleanup() function is called once when the [STOP] button is pressed
	print(string.format("cleanup %.2f", RunTime()));
	-- Do nothing
	return true;		-- false=cleanup failed, true=cleanup succeeded
	end
--[[---------------------------------------------------------------------------------------]]
function tick()
	-- the tick() function is called once per second
	-- do not call Sleep() from this function
	print(string.format("tick --> %.2f", RunTime()));
	-- Do nothing;
	return true;	-- false=stop calling tick(), true=continue to tick
	end
--[[---------------------------------------------------------------------------------------]]
function DL()
	-- the DL() function is called when the Function 1 button is pressed
	print("Do Nothing : PCNo = " .. PCNo() .. " Debug " .. Debug());
	-- Do almost nothing	
	BumpCounter(COUNTER01);
	return true;
	end
Function01Name, Function01Label = DL, 'Print("Do Nothing")';
--[[---------------------------------------------------------------------------------------]]

-- Semicolons are not required in Lua code
-- Do Nothing Tag Test
title = "Do Nothing Tag Test"
--
-- This test runs a simple "do nothing" script with tag detection enabled
--
require("defines");
require("functions");

local MyEngineNo, MyTIUNo;

-- Counter Labels
Counter01Label = "Do Nothing";

--[[---------------------------------------------------------------------------------------]]
function setup(Engine, TIU)
	-- the setup() function is called once at the beginning of the run
	MyEngineNo = Engine;	-- Engine number selected on the RTC Main window
	MyTIUNo = GetTIUNo(MyEngineNo);	-- TIU associated with MyEngineNo
	
	print("setup(): Engine Number " .. MyEngineNo .. " TIU Number " .. MyTIUNo .. " Debug " .. Debug());
	-- Do nothing	
	return true;		-- false=setup failed, true=setup succeeded
	end
--[[---------------------------------------------------------------------------------------]]
function tag(Detector, Reader, EngineNo, TagLocation, CarModel, Railroad, CarNumber, TagPacket)
	-- this function is called each time a tag is detected
	-- this function always waits until loop() finishes
	if (EngineNo > 0) then	-- its an engine
		print(string.format([[tag(%.2f) : Detector %d Reader %d EngineNo %d TagLocation %d EngineModel %d]],
			RunTime(), Detector, Reader, EngineNo, TagLocation, CarModel));
		else	-- it's a car
		print(string.format([[tag(%.2f) : Detector %d Reader %d CarModel %d]], RunTime(),
			Detector, Reader, CarModel));
		end
	-- Do nothing
	return true;
	end
--[[---------------------------------------------------------------------------------------]]
function cleanup()
	-- the cleanup() function is called once when the [STOP] button is pressed
	print(string.format("cleanup %.2f", RunTime()));
	-- Do nothing
	return true;		-- false=cleanup failed, true=cleanup succeeded
	end
--[[---------------------------------------------------------------------------------------]]
function tick()
	-- the tick() function is called once per second
	-- do not call Sleep() from this function
	print(string.format("tick --> %.2f", RunTime()));
	-- Do nothing;
	return true;	-- false=stop calling tick(), true=continue to tick
	end
--[[---------------------------------------------------------------------------------------]]
function DL()
	-- the DL() function is called when the Function 1 button is pressed
	print("Do Nothing : PCNo = " .. PCNo() .. " Debug " .. Debug());
	-- Do almost nothing	
	BumpCounter(COUNTER01);
	return true;
	end
Function01Name, Function01Label = DL, 'Print("Do Nothing")';
--[[---------------------------------------------------------------------------------------]]

--[[---------------------------------------------------------------------------------------]]
function tick()
	-- Do not call Sleep() from this function
	print("tick " .. RunTime());
	-- do something
	return true;
	end
--[[---------------------------------------------------------------------------------------]]

Functions that return information about Engines and Lashups

Send any Command to the TIU

-- Semicolons are not required in Lua code
title = "Startup/Shutdown Test"
require("defines");

local MyEngineNo, MyTIUNo;
--[[---------------------------------------------------------------------------------------]]
function setup(Engine)
	-- this function is called once when the [Run Script] button is pushed
	-- Engine : Engine number selected on the RTC Main window
	-- TIU : TIU number selected on the RTC Main window
	print("setup()");

	MyEngineNo = Engine;	-- Engine number selected on the RTC Main window
	MyTIUNo = GetTIUNo(MyEngineNo);	-- TIU associated with MyEngineNo
	-- debug level as selected on the Debug window, values 0 (off) to 9 (maximum)
	if (Debug() > 0) then 
		print(string.format("setup(): Debug level %d", Debug())); 
		print("setup(): Engine Number " .. MyEngineNo .. " TIU Number " .. MyTIUNo);
		end
	print("TIU : " .. MyTIUNo);
	assert((MyTIUNo >= 1 and MyTIUNo <= 5), "TIU Number out of range");
	-- initialize the layout as needed
	AC, IAC = Counts();	-- Counts() returns two values
	print("TIU" .. MyTIUNo .. ": " .. AC .. " Active Engines - " .. IAC .. " Inactive Engines");
	-- switches and accessories
	AIUNo = 1;
	Switch(STRAIGHT, 1, AIUNo, MyTIUNo, 3, MyEngineNo);  -- College East
	Switch(STRAIGHT, 2, AIUNo, MyTIUNo, 5, MyEngineNo);  -- College West
	Sleep(10);
	return true;		-- false=setup failed, true=setup succeeded
	end
--[[---------------------------------------------------------------------------------------]]
function loop()
	-- This function is called once after setup() completes and returns false.
	-- You must press [STOP] to run cleanup() and finish the script.
	-- TIU : TIU number selected on the RTC Main window
	-- debug level as selected on the Debug window, values 0 (off) to 9 (maximum)
	print(string.format("loop(): EngineNo %d TIUNo %d", MyEngineNo, MyTIUNo));
	if (Debug() > 0) then 
		print("Debug level " .. Debug());
		end
	StartUp(0, MyEngineNo, MyTIUNo);
	Sleep(10);
	Whistle(ON, 20, MyEngineNo, MyTIUNo);
	Whistle(OFF, 22, MyEngineNo, MyTIUNo);
	print(string.format("loop() Sleep(10) Started at %.2f", RunTime()));
	Sleep(10);
	print(string.format("loop() Sleep(10) Complete at %.2f", RunTime()));

	for Count = 1, 2 do
		Bell(ON, 15, MyEngineNo, MyTIUNo);
		Bell(OFF, 20, MyEngineNo, MyTIUNo);			
		Sleep(10);
		end
	-- after this functions returns, the Dispatch List will continue to empty until all commands are sent.
	return false;	-- false=do not loop, true=continue to loop
	end
--[[---------------------------------------------------------------------------------------]]
function cleanup()
	-- this function is called once when the user presses the [STOP] button
	--print("cleanup()");
	ShutDown(0, MyEngineNo, MyTIUNo);
	print(string.format("cleanup() Complete at %.2f", RunTime()));
	--
	return true;		-- false=cleanup failed, true=cleanup succeeded
	end
--[[---------------------------------------------------------------------------------------]]
function BlowWhistle()
	print("BlowWhistle()");
	print(string.format("BlowWhistle(): Eng %d TIU %d", MyEngineNo, MyTIUNo));
	print("BlowWhistle(): Eng " .. MyEngineNo .. " TIU " .. MyTIUNo .. " Debug " .. Debug());
	Whistle(ON, 0, MyEngineNo, MyTIUNo);
	Whistle(OFF, 1, MyEngineNo, MyTIUNo);
	return true;
end
Function01Name, Function01Label = BlowWhistle, "Blow Whistle";
--[[---------------------------------------------------------------------------------------]]
function SimplePrint()
	print("SimplePrint()");
	print(string.format("SimplePrint(): Eng %d TIU %d", MyEngineNo, MyTIUNo));
	return true;
end
Function02Name, Function02Label = SimplePrint, "Simple Print";
-- you can create 10 functions which get hooked to the 10 button on the Program Control window
--[[---------------------------------------------------------------------------------------]]
function NOP()
	print("NOP()");
	print(string.format("NOP() : Eng %d TIU %d", MyEngineNo, MyTIUNo));
	return true;
end
Function10Name, Function10Label = NOP, "NOP";
--[[---------------------------------------------------------------------------------------]]

--[[---------------------------------------------------------------------------------------]]
function BlowWhistle(Eng, TIU)
	print("BlowWhistle()");
	print(string.format("BlowWhistle(): Eng %d TIU %d Debug %d", Eng, TIU, Debug()));
	print("BlowWhistle(): Eng " .. Eng .. " TIU " .. TIU .. " Debug " .. Debug());
	Whistle(ON, 0, Eng, TIU);
	Whistle(OFF, 1, Eng, TIU);
	return true;
end
Function01Name, Function01Label = BlowWhistle, "Blow Whistle";
--[[---------------------------------------------------------------------------------------]]
function SimplePrint(Eng, TIU)
	print("SimplePrint()");
	print(string.format("SimplePrint(): Eng %d TIU %d Debug %d", Eng, TIU, Debug()));
	return true;
end
Function02Name, Function02Label = SimplePrint, "Simple Print";
-- you can create 30 functions which get hooked to the 30 button on the Program Control window
--[[---------------------------------------------------------------------------------------]]
function NOP(Eng, TIU)
	print("NOP() This script does (almost) nothing");
	print(string.format("NOP() : Eng %d TIU %d Debug %d", Eng, TIU, Debug()));
	return true;
end
Function10Name, Function10Label = NOP, "NOP";
--[[---------------------------------------------------------------------------------------]]

-- Semicolons are not required in Lua code
-- Counter and Function Label Test
title = "Counter and Function Label Test and Tick Test"
require("defines");

-- Counter Labels
Counter01Label = "Engines Detected";
Counter02Label = "State Machine";
Counter03Label = "Counter03";
Counter04Label = "Counter04";
Counter05Label = "Counter05";

ENGDET = COUNTER01;
SMSTATES = COUNTER02;
EnginesUsed = {"GP38-2", "GP7", "SW1500"};
--[[---------------------------------------------------------------------------------------]]
function setup(Engine, TIU)
	for idx,Eng in ipairs(EnginesUsed) do
		BumpCounter(ENGDET);	-- Engines Detected counter should bump to 3
		print(idx .. " Engine " .. Eng);	
		end
	BumpCounter(COUNTER03);
	TIUSerialPortConnected, TIUConnected, RFIDSerialPortConnected = CommStatus();	
	print("TIUSerialPortConnected : " .. tostring(TIUSerialPortConnected) .. " - TIUConnected : " .. tostring(TIUConnected) .. " - RFIDSerialPortConnected : " .. tostring(RFIDSerialPortConnected));
	if (RFIDSerialPortConnected) then
		print("Turn off RFID Enable and rerun");
		return false;
		end;
	
	return true;
	end
--[[---------------------------------------------------------------------------------------]]	
function loop(Engine, TIU)
	-- Always call Sleep() at least once in this function.
	BumpCounter(SMSTATES);		-- bump states counter
	Sleep(10);
	return true;	-- false=do not loop, true=continue to loop
	end
--[[---------------------------------------------------------------------------------------]]	
function cleanup(Engine, TIU)
	BumpCounter(SMSTATES);		-- bump states counter
	BumpCounter(COUNTER05);
	print("Counter01 = " .. GetCounter(COUNTER01));
	print("Counter02 = " .. GetCounter(COUNTER02));
	print("Counter03 = " .. GetCounter(COUNTER03));
	print("Counter04 = " .. GetCounter(COUNTER04));
	print("Counter05 = " .. GetCounter(COUNTER05));
	print("Counter06 = " .. GetCounter(COUNTER06));
	--
	return true;
	end
--[[---------------------------------------------------------------------------------------]]
function tick(Engine, TIU)
	print(string.format("tick %.2f", RunTime()));
	BumpCounter(COUNTER04);
	return true;
	end
--[[---------------------------------------------------------------------------------------]]
Function01Name, Function01Label = loop, "Loop01";	
Function02Name, Function02Label = loop, "Loop02";	
Function03Name, Function03Label = loop, "Loop03";	
Function04Name, Function04Label = loop, "Loop04";	
Function05Name, Function05Label = cleanup, "Cleanup05";
Function06Name, Function06Label = setup, "Setup06";
Function07Name, Function07Label = setup, "Setup07";
Function08Name, Function08Label = setup, "Setup08";
Function09Name, Function09Label = setup, "Setup09";
Function10Name, Function10Label = tick, "tick10";
--[[---------------------------------------------------------------------------------------]]

-- Semicolons are not required in Lua code
title = "LED Test"

SwitchCase = 0;

require("defines");
require("functions");

--[[---------------------------------------------------------------------------------------]]
function setup(Engine, TIU)
	-- this function is called once when the [Run Script] button is pushed
	print("setup()");
	SetLED(1, clGreen, "Speed");	-- set status LED to green
	SetLED(2, clClear, "%");	-- set status LED to clear	
	SetLED(3, clRed, "Error");	-- set status LED to red		
	SetLED(4, clYellow, "Warning");	-- set status LED to yellow	
	return true;
end
--[[---------------------------------------------------------------------------------------]]
function loop()	-- parameters not used
	-- Always call Sleep() at least once in this function since it returns true;
	Sleep(1);
	-- cycle the LED through different colors and states
	if (SwitchCase == 0) then
		SwitchCase = 1;
		SetLED(1,clYellow);
		SetLED(2,clGreen);
		SetLED(3,clClear);
		SetLED(4,clRed);
		return true;
		end
	if (SwitchCase == 1) then
		SwitchCase = 2;
		SetLED(1,clRed);
		SetLED(2,clYellow);
		SetLED(3,clGreen);
		SetLED(4,clClear);
		return true;
		end
	if (SwitchCase == 2) then
		SwitchCase = 3;
		SetLED(1,clClear);
		SetLED(2,clRed);
		SetLED(3,clYellow);
		SetLED(4,clGreen);		
		return true;
		end
	if (SwitchCase == 3) then
		SwitchCase = 0;
		SetLED(1,clGreen);
		SetLED(2,clClear);
		SetLED(3,clRed);
		SetLED(4,clYellow);		
		return true;
		end	
	return true;
end
--[[---------------------------------------------------------------------------------------]]
function cleanup(Engine, TIU)
--
	SetLED(1, clClear);
	SetLED(2, clClear);
	SetLED(3, clClear);
	SetLED(4, clClear);

return true;
end
--[[---------------------------------------------------------------------------------------]]

-- Semicolons are not required in Lua code
title = "3 Engine Demo"

-- This script is written to use 3 engines. The Engine List on the Main window
-- should have exactly three active engines and the rest should be inactive.

requrie("defines");
require("functions");

MyTIUNo = 99;	-- Global TIU number
MyDebug = 0;	-- Global Debug Value

DETECTED = true;
NOTDETECTED = false;

STOPDELAY = 2;	-- delay from tag detection to engine speed 0 command

-- all tables in Lua are 1 based, that is, T[1] is the first item in the list
EngineDetectionOrder = {0};	-- clear the tables
EnginesUsedNum = {0};
EnginesUsedFlag = {0};
EngineSpeedSave = {0};
Got = {0};
-- Counter Labels
Counter01Label = "Engines Detected";
Counter02Label = "State Machine";
-- table to hold all of the tags detected in sequence
Tags = {};
-- state machine states
IDLE = 0;
DETECTENGINES = 1;
READYGO_3 = 2;
READYGO_3a = 3;
READYGO_3b = 4;
SM = IDLE;

--[[---------------------------------------------------------------------------------------]]
function setup(Engine, TIU)
	-- this function is called once when the [Run Script] button is pushed
	print("setup()");
	-- Engine number selected on the Main window is not used
	MyTIUNo = TIU;		-- TIU number selected on the Main window
	MyDebug = Debug();	-- debug level, values 0 (off) to 9 (maximum)
	if (MyDebug > 0) then print(string.format("Debug level %d", MyDebug)); end
	if (MyDebug > 0) then print("Debug level " .. tonumber(MyDebug)); end
	-- initialize variables
	TagCount = 0;
	iEngineCount = 0;
	iEngineDetectionCount = 0;
	iReqEngines = 3;	-- number of engines required for this program
	UniqueTagCount = 0;	-- number of unique tags found
	
	-- make sure that RFID is connected
	TIUSerialPortConnected, TIUConnected, RFIDSerialPortConnected = CommStatus();	
	print("TIUSerialPortConnected : " .. tostring(TIUSerialPortConnected) .. " - TIUConnected : " .. tostring(TIUConnected) .. " - RFIDSerialPortConnected : " .. tostring(RFIDSerialPortConnected));
	if (not RFIDSerialPortConnected) then
		print("RFID Port must be enabled for this script");
		return false;	-- false=setup failed
		end

	math.randomseed(os.time());	-- random seed
	assert(true);	-- debug only	
	-- initialize the layout

	-- Start All Active Engines - 1-99 (DCS 2-100)
	print("Starting All Active Engines");

	for iEng = 1, 99 do	-- check all possible engines on one TIU
		if (Exists(iEng)) then
			if (IsActive(iEng)) then
				print("Engine " .. iEng .. " Starting");
				EngineStartUp(iEng, MyTIUNo);
				Sleep(2);
				end
			end
			
		if (IsEngineRunning(iEng, MyTIUNo)) then	-- IsConsistRunning() REQUIRES use of StartUpActiveEngines() or EngineStartUp()
			print(string.format("Initalizing Engine %d", iEng));
			-- save the numbers of all started engines
			iEngineCount = iEngineCount + 1;			-- Count the number of engines running
			EnginesUsedNum[iEngineCount] = iEng;		-- EnginesUsedXXXX[] is 1 based
			EnginesUsedFlag[iEngineCount] = NOTDETECTED;-- flag as not yet detected in motion
	   		-- Numberboards
			Setting(CMD_NUMBERBOARDS_ON,  18, iEng, MyTIUNo);	-- not a dedicated switch
			-- Set smoke off
			Smoke(OFF, 2, iEng, MyTIUNo);
			-- Cab Chatter Off
			CabChat(OFF, 3, iEng, MyTIUNo);
			-- Set Marker lights on
			Markers(ON, 15, iEng, MyTIUNo);
			-- Set Acc/Dec rate to 1/1 Smph/sec
			Rate(1, 1, 0, iEng, MyTIUNo);
			end
		end
	print(string.format("Engines Started %d", iEngineCount));
	-- Start each train moving forward - go slow to help insure tag detection
	-- Since we don't know the position of each engine, we start each at exactly
	-- the same speed at exactly the same time, once we have detected the engines
	-- and located them on the layout, we can vary the movement times and running speeds.
	for iDex = 1, iEngineCount do	-- for each running engine, set the speed to 12 Smph
		local iEng = EnginesUsedNum[iDex];	-- EnginesUsedXXXX[] is 1 based
		print(string.format("SetSpeed for Engine : %d", iEng));
		SetSpeed(12, 20, iEng, MyTIUNo);
		end

	-- set State Machine to first state
	SM = DETECTENGINES;
	return true;	-- false=setup failed, true=setup succeeded
	end
--[[---------------------------------------------------------------------------------------]]
function tag(Detector, Reader, EngineNo, TagLocation, CarModel, Railroad, CarNumber, TagPacket)
	-- this function is called each time a tag is detected
	-- Line below shows a different way to quote a string using brackets
	if (MyDebug > 4) then Beep();	end;	-- sound a tone
	if (MyDebug > 1) then
		if (EngineNo > 0) then	-- its an engine
			print(string.format([[tag() : Detector %d Reader %d EngineNo %d TagLocation %d CarModel %d]],Detector, Reader, EngineNo, TagLocation, CarModel));
			else	-- it's a car
			print(string.format([[tag() : Detector %d Reader %d CarModel %d]],Detector, Reader, CarModel));
			end
		end
	-- The complete packet received is in TagPacket 
	-- (some of the most used fields have already been extracted into the first parameters to tag()
	--   First 8 digits are the 4 byte Tag UID in hexidecimal
	--   Final 32 digits are the 16 bytes of Block 4 Information read from the Tag in hexidecimal
	if (MyDebug > 4) then print(string.format("Packet  %s", TagPacket)); end
	Tags[string.sub(TagPacket,1,8)] = string.sub(TagPacket,9);
	TagCount = TagCount + 1;	-- count the number of tags
	
--[[---------------------------------------------------------------------------------------]]
-- STATE MACHINE
--[[---------------------------------------------------------------------------------------]]	

--[[---------------------------------------------------------------------------------------]]	
	if (SM == IDLE) then	-- do nothing 
		return true;
		end
--[[---------------------------------------------------------------------------------------]]		
	if (SM == DETECTENGINES) then
		-- As engines run around the layout, go until all of them are detected by Detector 1 reader 0
		-- Save the tag in the tag list
		--
		-- TBD - add test to be sure that we detected tags from all tag readers
		--
		-- single toot on engine rear truck detection from all detectors and readers
		if (isEngine(EngineNo) and isTagRear(TagLocation)) then
			PlaySound(41, 0, EngineNo, MyTIUNo); -- Short Toot
			end
			
		-- Schedule a random noise on engine rear truck detection on all detectors and all readers
		if (isEngine(EngineNo) and isTagRear(TagLocation)) then
			RandomAction(EngineNo, MyTIUNo);
			end
			
		if (isEngine(EngineNo) and isTagFront(TagLocation) and ((isDetector(Detector, 1) and isReader(Reader, 0)))) then
			for iDex = 1, iEngineCount do
				-- EnginesUsedXXX[] is 1 based
				if (EnginesUsedNum[iDex] == EngineNo) then 	-- is the engine in the Engine List?
					if (EnginesUsedFlag[iDex] == DETECTED) then		-- has it already been detected (then all engines looped)
						-- already detected so we have detected them all
						print ("All Engines Detected");
						-- speed up the engines to 20 Smph for the first loop
						-- make the speed up from 12 to 20 more gradual
						for jDex = 1, iEngineDetectionCount do
							SetSpeed(15, 3, EngineDetectionOrder[jDex], MyTIUNo);
							SetSpeed(18, 6, EngineDetectionOrder[jDex], MyTIUNo);
							SetSpeed(20, 9, EngineDetectionOrder[jDex], MyTIUNo);
							end
						-- at this point, EngineDetectionOrder[1] is just beyond Detector 1 Reader 0
						Got = {false, false, false};	-- set all Got[] to false
						-- Require three engines to run this script
						if (iEngineCount == 3) then 
							SM = READYGO_3; 
							print("Three Engines Detected");
							else 
							SM = IDLE;
							print("Three Engines Not Detected, setting state machine to IDLE");
							end
						PFADelay = 0;
						Detector1Passenger = false;
						-- All engines have been detected and we know their order on the layout
						return true;
						end
					-- At this point, we have detected a new engine
					EnginesUsedFlag[iDex] = DETECTED;	-- flag as detected in motion - EnginesUsed[] is 0 based
					-- EngineDetectionOrder[] is 1 based
					iEngineDetectionCount = iEngineDetectionCount + 1;	-- Count number of detected engines
					EngineDetectionOrder[iEngineDetectionCount] = EngineNo;	-- remember the detection order
					print(string.format("Engine # %d detected (Index : %d)", EngineNo, iEngineDetectionCount));
					BumpCounter(COUNTER01);	-- bump the Engines Detected Counter on the Program Control window
					return true;
					end
				end
			end
		-- continue in this state
		return true;
		end
--[[---------------------------------------------------------------------------------------]]
	if (SM == READYGO_3) then
		-- All engines are detected, their order is known - stop them over a reader
		-- This should pick off the engines starting at the last one. This would make
		-- sure that if two engines are between detectors, we pick them off from the last one
		--
		-- The state machine will now loop over three states, READYGO_3, READYGO_3a, and READYGO_3b.
		-- Each state will move the engine up to the next detector and then stop it there.
		--
		-- Schedule a random noise on engine rear truck detection on all detectors and all readers
		if (isEngine(EngineNo) and isTagRear(TagLocation)) then
			RandomAction(EngineNo, MyTIUNo);
			end
			
		-- run first [1] engine to Detector 3 Reader 0
		-- Detect both front and rear tags as a double check to make sure we detected an engine
		if (isEngine(EngineNo) and ((isDetector(Detector, 3) and isReader(Reader, 0)))) then
			if (EngineNo == EngineDetectionOrder[1]) then
				if (Got[1]) then Throttle(0, STOPDELAY, EngineDetectionOrder[1], MyTIUNo); end			-- already detected set Throttle to 0
				if (not Got[1]) then SetSpeed(0, STOPDELAY, EngineDetectionOrder[1], MyTIUNo); end
				Got[1] = true;
				end
			end
			
		-- run second [2] engine to Detector 2 Reader 0 or Reader 1
		-- Detect both front and rear tags as a double check to make sure we detected an engine
		if (isEngine(EngineNo) and ((isDetector(Detector, 2) and isReader(Reader, 0)) or (isDetector(Detector, 2) and isReader(Reader, 1)))) then
			if (EngineNo == EngineDetectionOrder[2]) then
				if (Got[2]) then Throttle(0, STOPDELAY, EngineDetectionOrder[2], MyTIUNo); end			-- already detected set Throttle to 0
				if (not Got[2]) then SetSpeed(0, STOPDELAY, EngineDetectionOrder[2], MyTIUNo); end
				Got[2] = true;
				end
			end
			
		-- run third [3] engine to Detector 1 Reader 0
		-- Detect both front and read tags as a double check to make sure we detected an engine
		if (isEngine(EngineNo) and ((isDetector(Detector, 1) and isReader(Reader, 0)))) then
			if (EngineNo == EngineDetectionOrder[3]) then
				if (Got[3]) then Throttle(0, STOPDELAY, EngineDetectionOrder[3], MyTIUNo); end			-- already detected set Throttle to 0
				if (not Got[3]) then SetSpeed(0, STOPDELAY, EngineDetectionOrder[3], MyTIUNo); end
				Got[3] = true;
				end
			if (isCarModel(CarModel, GP7) and isTagFront(TagLocation)) then	-- Special sounds for GP7 #1501
				local iDly = GP7PFA(0, EngineNo, MyTIUNo);
				if (iDly > PFADelay) then	
					PFADelay = iDly;
					end
				end				
			-- set flag if a passenger train being pulled by a GP7 was detected
			if (isCarModel(CarModel, GP7)) then
				Detector1Passenger = true;
				else
				Detector1Passenger = false;
				end
			end

		if (Got[1] and Got[2] and Got[3]) then 	-- set speed for all engines and go to next state
			if (math.random(5) == 1) then		-- Special sounds for SW1200  #1208  Engine #4
				local iDly = SW1200PFA(0, 4, MyTIUNo);
				if (iDly > PFADelay) then
					PFADelay = iDly;
					end
				end
			-- Counter to keep track of States
			BumpCounter(COUNTER02);		-- bump the Counter02 on the Program Control window

			SetSpeed(15 + math.random(5), PFADelay + 8 + math.random(20), EngineDetectionOrder[1], MyTIUNo);	-- @Detector 3 Reader 0
			SetSpeed(15 + math.random(5), PFADelay + 8 + math.random(20), EngineDetectionOrder[2], MyTIUNo);	-- @Detector 2 Reader 0
			SetSpeed(15 + math.random(5), PFADelay + 8 + math.random(20), EngineDetectionOrder[3], MyTIUNo);	-- @Detector 1 Reader 0
			--
			-- if a passenger train is leaving Detector 1 Reader 0, set switches to diverge
			-- otherwise, set the switches to straight
			-- Both after the appropriate delay to let the trains get underway
			if (Detector1Passenger) then
				-- set the switches to diverge, Engine Number is not used but must be specified
				print("College East & West set to THROWN/DIVERGE in " .. PFADelay + 8 + 35 + 20);
				Switch(DIVERGE, 1, 1, PFADelay + 8 + 35 + 20, EngineNo, MyTIUNo);  -- College East
				Switch(DIVERGE, 1, 2, PFADelay + 8 + 35 + 23, EngineNo, MyTIUNo);  -- College West
				Detector1Passenger = false;
				else
				-- set the switches to straight, Engine Number is not used but must be specified
				print("College East & West set to CLOSED/STRAIGHT in " .. PFADelay + 8 + 35 + 20);
				Switch(STRAIGHT, 1, 1, PFADelay + 8 + 35 + 20, EngineNo, MyTIUNo);  -- College East
				Switch(STRAIGHT, 1, 2, PFADelay + 8 + 35 + 23, EngineNo, MyTIUNo);  -- College West
				end
			Got = {false, false, false};	-- set all Got[] to false
			SM = READYGO_3a;	-- go to next state
			PFADelay = 0;
			end
		-- continue in this state
		return true;	
		end		
--[[---------------------------------------------------------------------------------------]]		
	if (SM == READYGO_3a) then

		-- All engines are detected, their order is known - stop them over a reader
		-- Schedule a random noise on engine rear truck detection on all detectors and all readers
		if (isEngine(EngineNo) and isTagRear(TagLocation)) then
			RandomAction(EngineNo, MyTIUNo);
			end

		-- run first [1] engine to Detector 1 Reader 0
		-- Detect both front and rear tags as a double check to make sure we detected an engine
		if (isEngine(EngineNo) and ((isDetector(Detector, 1) and isReader(Reader, 0)))) then
			if (EngineNo == EngineDetectionOrder[1]) then
				if (Got[1]) then Throttle(0, STOPDELAY, EngineDetectionOrder[1], MyTIUNo); end			-- already detected set Throttle to 0
				if (not Got[1]) then SetSpeed(0, STOPDELAY, EngineDetectionOrder[1], MyTIUNo); end
				Got[1] = true;
				end
			if (isCarModel(CarModel, GP7) and isTagFront(TagLocation)) then	-- Special sounds for GP7 #1501
				local iDly = GP7PFA(0, EngineNo, MyTIUNo);
				if (iDly > PFADelay) then
					PFADelay = iDly;
					end
				end
			-- set flag if a passenger train being pulled by a GP7 was detected
			if (isCarModel(CarModel, GP7)) then
				Detector1Passenger = true;
				else
				Detector1Passenger = false;
				end
			end

		-- run second [2] engine to Detector 3 Reader 0
		-- Detect both front and read tags as a double check to make sure we detected an engine
		if (isEngine(EngineNo) and ((isDetector(Detector, 3) and isReader(Reader, 0)))) then
			if (EngineNo == EngineDetectionOrder[2]) then
				if (Got[2]) then Throttle(0, STOPDELAY, EngineDetectionOrder[2], MyTIUNo); end			-- already detected set Throttle to 0
				if (not Got[2]) then SetSpeed(0, STOPDELAY, EngineDetectionOrder[2], MyTIUNo); end
				Got[2] = true;
				end
			end
		-- run third [3] engine to Detector 2 Reader 0 or Reader 1
		-- Detect both front and read tags as a double check to make sure we detected an engine
		if (isEngine(EngineNo) and ((isDetector(Detector, 2) and isReader(Reader, 0)) or (isDetector(Detector, 2) and isReader(Reader, 1)))) then
			if (EngineNo == EngineDetectionOrder[3]) then
				if (Got[3]) then Throttle(0, STOPDELAY, EngineDetectionOrder[3], MyTIUNo); end			-- already detected set Throttle to 0
				if (not Got[3]) then SetSpeed(0, STOPDELAY, EngineDetectionOrder[3], MyTIUNo); end
				Got[3] = true;
				end
			end

		if (Got[1] and Got[2] and Got[3]) then 	-- set speed for all engines and go to next state
			-- Counter to keep track of States
			BumpCounter(COUNTER02);		-- bump the Counter02 on the Program Control window
			
			SetSpeed(14 + math.random(5), PFADelay + 8 + math.random(20), EngineDetectionOrder[1], MyTIUNo);	-- @Detector 1 Reader 0
			SetSpeed(14 + math.random(5), PFADelay + 8 + math.random(20), EngineDetectionOrder[2], MyTIUNo);	-- @Detector 3 Reader 0
			SetSpeed(14 + math.random(5), PFADelay + 8 + math.random(20), EngineDetectionOrder[3], MyTIUNo);	-- @Detector 2 Reader 0
			--
			-- if a passenger train is leaving Detector 1 Reader 0, set switches to diverge
			-- otherwise, set the switches to straight
			-- Both after the appropriate delay to let the trains get underway
			if (Detector1Passenger) then
				-- set the switches to diverge, Engine Number is not used but must be specified
				print("College East & West set to THROWN/DIVERGE in " .. PFADelay + 8 + 35 + 20);
				Switch(DIVERGE, 1, 1, PFADelay + 8 + 35 + 20, EngineNo, MyTIUNo);  -- College East
				Switch(DIVERGE, 1, 2, PFADelay + 8 + 35 + 23, EngineNo, MyTIUNo);  -- College West
				Detector1Passenger = false;
				else
				-- set the switches to straight, Engine Number is not used but must be specified
				print("College East & West set to CLOSED/STRAIGHT in " .. PFADelay + 8 + 35 + 20);
				Switch(STRAIGHT, 1, 1, PFADelay + 8 + 35 + 20, EngineNo, MyTIUNo);  -- College East
				Switch(STRAIGHT, 1, 2, PFADelay + 8 + 35 + 23, EngineNo, MyTIUNo);  -- College West
				end
			Got = {false, false, false};	-- set all Got[] to false
			SM = READYGO_3b;	-- go to next state
			PFADelay = 0;
			end

		-- continue in this state
		return true;	
		end	
--[[---------------------------------------------------------------------------------------]]		
	if (SM == READYGO_3b) then
		-- All engines are detected, their order is known - stop them over a reader
		-- Schedule a random noise on engine rear truck detection on all detectors and all readers
		if (isEngine(EngineNo) and isTagRear(TagLocation)) then
			RandomAction(EngineNo, MyTIUNo);
			end

		-- run first [1] engine to Detector 2 Reader 0 or Reader 1
		-- Detect both front and rear tags as a double check to make sure we detected an engine
		if (isEngine(EngineNo) and ((isDetector(Detector, 2) and isReader(Reader, 0)) or (isDetector(Detector, 2) and isReader(Reader, 1)))) then
			if (EngineNo == EngineDetectionOrder[1]) then
				if (Got[1]) then Throttle(0, STOPDELAY, EngineDetectionOrder[1], MyTIUNo); end			-- already detected set Throttle to 0
				if (not Got[1]) then SetSpeed(0, STOPDELAY, EngineDetectionOrder[1], MyTIUNo); end
				Got[1] = true;
				end
			end
			
		-- run second [2] engine to Detector 1 Reader 0
		-- Detect both front and read tags as a double check to make sure we detected an engine
		if (isEngine(EngineNo) and ((isDetector(Detector, 1) and isReader(Reader, 0)))) then
			if (EngineNo == EngineDetectionOrder[2]) then
				if (Got[2]) then Throttle(0, STOPDELAY, EngineDetectionOrder[2], MyTIUNo); end			-- already detected set Throttle to 0
				if (not Got[2]) then SetSpeed(0, STOPDELAY, EngineDetectionOrder[2], MyTIUNo); end
				Got[2] = true;
				end
			if (isCarModel(CarModel, GP7) and isTagFront(TagLocation)) then	-- Special sounds for GP7 #1501
				local iDly = GP7PFA(0, EngineNo, MyTIUNo);
				if (iDly > PFADelay) then
					PFADelay = iDly;
					end				
				end				
			-- set flag if a passenger train being pulled by a GP7 was detected
			if (isCarModel(CarModel, GP7)) then
				Detector1Passenger = true;
				else
				Detector1Passenger = false;
				end
			end
			
		-- run third [3] engine to Detector 3 Reader 0
		-- Detect both front and read tags as a double check to make sure we detected an engine
		if (isEngine(EngineNo) and ((isDetector(Detector, 3) and isReader(Reader, 0)))) then
			if (EngineNo == EngineDetectionOrder[3]) then
				if (Got[3]) then Throttle(0, STOPDELAY, EngineDetectionOrder[3], MyTIUNo); end			-- already detected set Throttle to 0
				if (not Got[3]) then SetSpeed(0, STOPDELAY, EngineDetectionOrder[3], MyTIUNo); end
				Got[3] = true;
				end
			end

		if (Got[1] and Got[2] and Got[3]) then 	-- set speed for all engines and go to next state
			-- Counter to keep track of States
			BumpCounter(COUNTER02);		-- bump the Counter02 on the Program Control window
			SetSpeed(12 + math.random(5), PFADelay + 8 + math.random(20), EngineDetectionOrder[1], MyTIUNo);	-- @Detector 2 Reader 0
			SetSpeed(12 + math.random(5), PFADelay + 8 + math.random(20), EngineDetectionOrder[2], MyTIUNo);	-- @Detector 1 Reader 0
			SetSpeed(12 + math.random(5), PFADelay + 8 + math.random(20), EngineDetectionOrder[3], MyTIUNo);	-- @Detector 3 Reader 0
			--
			-- if a passenger train is leaving Detector 1 Reader 0, set switches to diverge
			-- otherwise, set the switches to straight
			-- Both after the appropriate delay to let the trains get underway
			if (Detector1Passenger) then
				-- set the switches to diverge, Engine Number is not used but must be specified
				print("College East & West set to THROWN/DIVERGE in " .. PFADelay + 8 + 35 + 20);
				Switch(DIVERGE, 1, 1, PFADelay + 8 + 35 + 20, EngineNo, MyTIUNo);  -- College East
				Switch(DIVERGE, 1, 2, PFADelay + 8 + 35 + 23, EngineNo, MyTIUNo);  -- College West
				Detector1Passenger = false;
				else
				print("College East & West set to CLOSED/STRAIGHT in " .. PFADelay + 8 + 35 + 20);
				-- set the switches to straight, Engine Number is not used but must be specified
				Switch(STRAIGHT, 1, 1, PFADelay + 8 + 35 + 20, EngineNo, MyTIUNo);  -- College East
				Switch(STRAIGHT, 1, 2, PFADelay + 8 + 35 + 23, EngineNo, MyTIUNo);  -- College West
				end
			Got = {false, false, false};	-- set all Got[] to false
			SM = READYGO_3;	-- go to next state
			PFADelay = 0;
			end
		-- continue in this state
		return true;
		end	
--[[---------------------------------------------------------------------------------------]]
	return true;	-- true=continue to process tags, false=stop processing tags
	end
--[[---------------------------------------------------------------------------------------]]
function cleanup(Engine, TIU)
	-- this function is called once when the user presses the [STOP] button
	print("cleanup()");
	for idx,Engine in ipairs(EnginesUsedNum) do		
		print(idx .. " Shutdown Engine " .. Engine);
		EngineShutDown(Engine, MyTIUNo);
		end	
	ShowTags(Engine, TIU);		-- dump out the Tags table
	return true;		-- false=cleanup failed, true=cleanup succeeded
	end
--[[---------------------------------------------------------------------------------------]]

function GP7PFA(when, EngineNo, TIUNo)
--
-- Run the GP7 PFA sequence
--
-- returns additional delay for PFA on success
--
local PFADelay = when + 38;
SetVolume(ENGINE_VOLUME, 25, when + 10, EngineNo, TIUNo);	-- reduce engine volume for the PFA sequence
PlaySound(110, when + 15, EngineNo, TIUNo); 	-- Now Boarding
PlaySound(111, when + 18, EngineNo, TIUNo); 	-- Ticketed Passengers Only
PlaySound(112, when + 21, EngineNo, TIUNo); 	-- Let me help you
PlaySound(113, when + 24, EngineNo, TIUNo); 	-- Let me take your baggage
PlaySound(114, when + 28, EngineNo, TIUNo); 	-- Thanks
PlaySound(115, when + 34, EngineNo, TIUNo); 	-- All Aboard
SetVolume(ENGINE_VOLUME, 100, when + 40, EngineNo, TIUNo);
print("GP7 PFA " .. PFADelay);
return PFADelay;
end
--[[---------------------------------------------------------------------------------------]]

function SW1200PFA(when, EngineNo, TIUNo)
--
-- Run the SW1200 PFA sequence
--
-- returns additional delay for PFA on success
--
local PFADelay = when + 6 + 20 + 73;	-- its a long sequence
StartUp(when + 6, EngineNo, MyTIUNo); 		-- Startup takes 20 seconds
-- when + 6 + 20
PlaySound(80, when + 6 + 20, EngineNo, TIUNo);
PlaySound(81, when + 6 + 20 + 5, EngineNo, TIUNo);
PlaySound(82, when + 6 + 20 + 5 + 10, EngineNo, TIUNo);
PlaySound(83, when + 6 + 20 + 5 + 10 + 3, EngineNo, TIUNo);
PlaySound(84, when + 6 + 20 + 5 + 10 + 3 + 4, EngineNo, TIUNo);
PlaySound(85, when + 6 + 20 + 5 + 10 + 3 + 4 + 4, EngineNo, TIUNo);
PlaySound(86, when + 6 + 20 + 5 + 10 + 3 + 4 + 4 + 5, EngineNo, TIUNo);
PlaySound(87, when + 6 + 20 + 5 + 10 + 3 + 4 + 4 + 5 + 3, EngineNo, TIUNo);
PlaySound(88, when + 6 + 20 + 5 + 10 + 3 + 4 + 4 + 5 + 3 + 5, EngineNo, TIUNo);
PlaySound(89, when + 6 + 20 + 5 + 10 + 3 + 4 + 4 + 5 + 3 + 5 + 5, EngineNo, TIUNo);
PlaySound(90, when + 6 + 20 + 5 + 10 + 3 + 4 + 4 + 5 + 3 + 5 + 5 + 4, EngineNo, TIUNo);
ShutDown	 (when + 6 + 20 + 5 + 10 + 3 + 4 + 4 + 5 + 3 + 5 + 5 + 4 + 5, EngineNo, TIUNo);
print("A&S SW1200 #1208 PFA " .. PFADelay);
return PFADelay;
end
--[[---------------------------------------------------------------------------------------]]
-----------------------------------------------------------------------------
-- Schedule a Random Noise
--
-- Params:
--		EngineNo
--		TIUNo
--
-- returns true on success
--
-----------------------------------------------------------------------------
function RandomAction(iEngineNo, iTIUNo)
-- Schedule a random noise
local retv = true;

-- pick sound/effect based on a random number
-- can be adjusted if there is too much or too little background noise
--
-- choose from:
-- 1. Turn the bell on for a random number of seconds
-- 2. Blow the horn/whistle for a random number of seconds
-- 3. Play the crossing sound n42
-- 4. Turn the smoke on for a random number of seconds
-- 5. Turn on Cab Chatter for a random number of seconds
-- 6. No sounds
--
local Starttime = 0;
local Endtime = 0;
local switchval = math.random(7);	-- returns 1 through 7
if (switchval == 1) then
		Starttime = 30 + math.random(10);
		Endtime = Starttime + 5 + math.random(5);
		Bell(ON, Starttime, iEngineNo, iTIUNo); 		-- send bell on
		Bell(OFF, Endtime, iEngineNo, iTIUNo);			-- send bell off
		print("RandomAction: Bell");
		end
if (switchval == 2) then
		Starttime = 25 + math.random(10);
		Endtime = Starttime + 3 + math.random(3);
		Whistle(ON, Starttime, iEngineNo, iTIUNo); 		-- send Whistle/Horn on
		Whistle(OFF, Endtime, iEngineNo, iTIUNo);		-- send Whistle/Horn off
		print("RandomAction: Horn/Whistle");
		end
if (switchval == 3) then
		Starttime = 25 + math.random(11);
		PlaySound(42, Starttime, iEngineNo, iTIUNo); 	-- SXS Toot
		print("RandomAction: SXS");
		end
if (switchval == 4) then
		Starttime = 25 + math.random(10);
		Endtime = Starttime + 46;
		Smoke(ON, Starttime, iEngineNo, iTIUNo);		-- send Smoke on
		Smoke(OFF, Endtime, iEngineNo, iTIUNo);			-- send Smoke off
		print("RandomAction: Smoke");
		end
if (switchval == 5) then
		Starttime = math.random(10);
		if (math.random(2) == 1) then	-- math.random returns 1 or 2
			CabChat(ON, Starttime, iEngineNo, iTIUNo);		-- set Cab Chatter on
			print("RandomAction: Cab Chatter On");
			else
			CabChat(OFF, Starttime, iEngineNo, iTIUNo);		-- set Cab Chatter off
			print("RandomAction: Cab Chatter Off");
			end
		end
if (switchval == 6) then
		-- No sounds some of the time
		print("RandomAction: Quiet");
		end
return retv;
end
--[[---------------------------------------------------------------------------------------]]

function SW1200Button(Eng, TIU)
	print("SW1200Button()");
	SW1200PFA(0, 4, TIU);		-- only works with Engine 4, the SW1200
	return true;
end
Function01Name, Function01Label = SW1200Button, "SW 1200 PFA";
--[[---------------------------------------------------------------------------------------]]
function GP7Button(Eng, TIU)
	print("GP7Button()");
	GP7PFA(0, 7, TIU);		-- only works with Engines 7 and 13, the GP7's
	return true;
end
Function02Name, Function02Label = GP7Button, "GP7 PFA";
--[[---------------------------------------------------------------------------------------]]
function PauseButton(Eng, TIU)
	print("PauseButton()");
	for idx,Engine in ipairs(EnginesUsedNum) do
		S1 = GetSpeed(Engine, MyTIUNo);	-- get Speed
		print(idx .. " Pause Engine " .. Engine .. " Speed " .. S1);
		EngineSpeedSave[idx] = S1;
		SetSpeed(0, 0, Engine, MyTIUNo);
		end
	return true;
end
Function06Name, Function06Label = PauseButton, "Pause";
--[[---------------------------------------------------------------------------------------]]
function ResumeButton(Eng, TIU)
	print("ResumeButton()");
	for idx,Engine in ipairs(EnginesUsedNum) do
		S1 = EngineSpeedSave[idx];		
		print(idx .. " Resume Engine " .. Engine .. " Speed " .. S1);
		SetSpeed(S1, 0, Engine, MyTIUNo);
		end
	return true;
end
Function07Name, Function07Label = ResumeButton, "Resume";
--[[---------------------------------------------------------------------------------------]]
function ShowTags(Eng, TIU)
	print("Tags detected:");
	for k,v in  pairs(Tags) do		-- dump out the Tags table
		print(k .. "  " .. v);
		end
	return true;
end
Function10Name, Function10Label = ShowTags, "Show Tags";
--[[---------------------------------------------------------------------------------------]]

--[[
---------------------------------------------------------------------------
Remote Train Control Program for Windows

© Copyright 2021 by Mark DiVecchio

	This file is part of Remote Train Control.

	Remote Train Control is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	Remote Train Control is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with Remote Train Control.  If not, see <http://www.gnu.org/licenses/>.

 Home Page : http://www.silogic.com/trains/RTC_Running.html
---------------------------------------------------------------------------]]

-- Semicolons are not required in Lua code
-- Commands from RTCMegaMaster.h
BELL_ON = "w4"
BELL_OFF = "bFFFB"
HDLT_ON ="ab1"
HDLT_OFF = "ab0"
WHISTLE_ON = "w2"
WHISTLE_OFF = "bFFFD"
DIRECTION_FORWARD = "d0"
DIRECTION_REVERSE = "d1"
DIRECTION_CHANGE = "d%d"
COMMAND_MODE = "m4"
COMMAND_STARTUP = "u4"
COMMAND_SHUTDOWN = "u5"
COMMAND_STARTUP_EXTENDED = "u6"
COMMAND_SHUTDOWN_EXTENDED = "u7"
COMMAND_STOP = "s0"
COUPLER_FRONT = "c0"
COUPLER_REAR = "c1"
SMOKE_EXHAUST_MIN = "ab12"
SMOKE_EXHAUST_MED = "ab11"
SMOKE_EXHAUST_MAX = "ab10"
SMOKE_EXHAUST_ON = "abF"
SMOKE_EXHAUST_OFF = "abE"
MARKERS_ON = "ab1C"
MARKERS_OFF = "ab1D"
BEACON_ON = "abD"
BEACON_OFF = "abC"
CAB_CHAT_ON = "ab13"
CAB_CHAT_OFF = "ab14"
CHUFF_RATE_2 = "g2"
CHUFF_RATE_4 = "g4"
COUPLER_CLASH = "h1"
--
AUX1_ON = "ab3"
AUX1_OFF = "ab2"
AUX2_ON = "ab4"
AUX2_OFF = "ab5"
AUX3_ON = "ab6"
AUX3_OFF = "ab7"
--
ACC_ON = "Ae%02d"
ACC_OFF = "Af%02d"
ACC_ALL_ON = "AaFFFFFFFFFFFFFF"
ACC_ALL_OFF = "Aa00000000000000"
SW_STRAIGHT = "Ac%02d"
SW_DIVERGE = "Ad%02d"
SW_ALL_STRAIGHT = "Ab05555555555555555555555555"
SW_ALL_DIVERGE = "Ab0AAAAAAAAAAAAAAAAAAAAAAAAA"
SW_CLOSED = SW_STRAIGHT
SW_THROWN = SW_DIVERGE
SW_ALL_CLOSED = SW_ALL_STRAIGHT
SW_ALL_THROWN = SW_ALL_DIVERGE
SPEED_SET = "s%d"
PLAY_SOUND = "n%d"
SINGLE_TOOT = "n41"
CROSSING = "n42"
DOUBLE_TOOT = "n43"
TRIPLE_TOOT = "n44"
IDLE_SOUND = "i%d"
VOLUME_CHANGE = "v%1d%03d"
MASTER_VOLUME = 0
ENGINE_VOLUME = 1
ACCENT_VOLUME = 2
HORN_VOLUME = 3
BELL_VOLUME = 4
COUPLER_CMD = "c%d"
FRONT = 0
REAR = 1
SETCMD = "ab%X"
CMD_HDLT_OFF = 0x00
CMD_HDLT_ON = 0x01
CMD_INT_OFF = 0x02
CMD_INT_ON = 0x03
CMD_MARS_OFF = 0x04
CMD_MARS_ON = 0x05
CMD_DITCH_OFF = 0x06
CMD_DITCH_ON = 0x07
CMD_BEACON_ON = 0x0D
CMD_BEACON_OFF = 0x0C
CMD_SMOKE_OFF = 0x0E
CMD_SMOKE_ON = 0x0F
CMD_SMOKE_MAX = 0x10
CMD_SMOKE_MED = 0x11
CMD_SMOKE_MIN = 0x12
CMD_MARKERS_ON = 0x1C
CMD_MARKERS_OFF = 0x1D
CMD_NUMBERBOARDS_ON = 0x05
CMD_NUMBERBOARDS_OFF = 0x04
ACC_RATE = "Da%d"
DEC_RATE = "Dd%d"
EMERGENCY_STOP = "o0"
LABOR_REV_UP = "r16"
LABOR_REV_DOWN = "r17"
LABOR_REV_NORMAL = "r15"

--[[---------------------------------------------------------------------------------------]]

-- Constants
-- Engine state
STARTED = true;
SHUTDOWN = false;
-- AIU Acessory state
ON = true;
OFF = false;
-- Engine direction
FORWARD = true;
REVERSE = false;
-- AIU switch position
STRAIGHT = true;
CLOSED = true;
NORMAL = true;
OPEN = false;
DIVERGE = false;
THROWN = false;
REVERSE = false;
-- Coupler
FRONT = true;
REAR = false;
--[[---------------------------------------------------------------------------------------]]
-- Speeds
NORMAL_SPEED = 60;
LIMITED_SPEED = 45;
MEDIUM_SPEED = 30;
SLOW_SPEED = 15;
RESTRICTED_SPEED = 15;

RAMMING_SPEED = 15;	-- speed in Smph that helps assure successful coupling
--[[---------------------------------------------------------------------------------------]]

-- Packet Constants from RTC_NFC.h
-- Engine Data in binary - 16 bytes
	  --TagID;	  -- 0 = tag not programmed, 0x88 = tag is programmed
		 TAG_PROGRAMMED = 0x88
	  --EngineNo;   -- 0 = not an Engine or LashUp (look at CarModel), otherwise Engine Number  1-99 (look at CarModel)
						  -- 101-120 LashUp Number
		 NOT_AN_ENGINE = 0
	  --TagLocation;  -- 0 = Tag not on a truck, 1 = Tag on Front truck, 2 = Tag on Rear truck (Engines and Cars)
		 NOT_ON_A_TRUCK = 0
		 TAG_ON_FRONT_TRUCK = 1
		 TAG_ON_REAR_TRUCK = 2
		 TAG_ON_TRUCK = 4
		 TAG_AT_MIDPOINT = 5
	  --EngineType; -- 0 = not an engine, 1 = Diesel,  2 = Steam (Engines Only)
		 NOT_AN_ENGINE = 0
		 DIESEL_ENGINE_TYPE = 1
		 STEAM_ENGINE_TYPE = 2	 
		 GAS_MECHANICAL_ENGINE_TYPE = 3
		 GAS_ELECTRIC_ENGINE_TYPE = 4
		 STEAM_TURBINE_ENGINE_TYPE = 5
		 ELECTRIC_TYPE = 6
		 TURBINE_TYPE = 7
		 DIESEL_MECHANICAL_TYPE = 8
	  --Coupler
		 NO_COUPLER = 0
		 REAR_REMOTE_COUPLER_ONLY = 1
		 FRONT_REMOTE_COUPLER_ONLY = 2
		 FRONT_AND_REAR_TEMOTE_COUPLERS = 3
		 COUPLER_UNKNOWN = 4
		 REAR_MANUAL_COUPLER_ONLY = 5
		 FRONT_MANUAL_COUPLER_ONLY = 6
		 FRONT_AND_REAR_REMOTE_COUPLERS = 7
		 REAR_DUMMY_COUPLER_ONLY = 8
		 FRONT_DUMMY_COUPLER_ONLY = 9
		 FRONT_DUMMY_AND_REAR_MANUAL_COUPLERS = 10
		 NOT_APPLICABLE = 0x80	-- Coupler is only used for Engines		 
	  --SXS;		-- 0 = no SXS Sound, 1 = has SXS sound at clip 42 (Engines only)
		 NO_SXS_SOUND = 0
		 HAS_SXS_SOUND = 1
	  --CarModel;	-- see below
		-- if EngineNo == NOT_AN_ENGINE
		 UNKNOWN_CARMODEL = 0 -- 0 = unknown
		 BOXCAR = 1 -- 1 = Boxcar
		 TANK_CAR = 2 -- 2 = Tank Car
		 FLAT_CAR = 3 -- 3 = Flat Car
		 CABOOSE = 4 -- 4 = Caboose
		 TENDER = 5 -- 5 = Tender
		 GONDOLA = 6 -- 6 = Gondola
		 COAL_HOPPER = 7 -- 7 = Coal Car
		 ORE_HOPPER = 8 -- 8 = Ore Car
		 MOW_FLATCAR = 9 -- 9 = MOW Flatcar
		 MOW_CRANE_CAR = 10 -- 10 = MOW Crane Car
		 MOW = 11 -- 11 = MOW Misc
		 COACH = 12 -- 12 = Passenger Coach
		 OBSERVATION = 13  -- 13 = Passenger Observation
		 BAGGAGE = 14 -- 14 = Baggage
		-- xx-255 TBD
		-- if EngineNo != NOT_AN_ENGINE (Lead Engine for LashUps)
		 UNKNOWN_ENGINEMODEL = 0 -- 0 = unknown
		 GP38_2 = 1 -- 1 = GP38-2
		 GP7 = 2 -- 2 = GP7
		 GP9 = 3 -- 3 = GP9
		 U28B = 4 -- 4 = U28B
		 BERKSHIRE = 5 -- 5 = Berkshire
		 DOODLEBUG = 6 -- 6 = Doodlebug
		 SW1200 = 7 -- 7 = SW1200
		 SW1500 = 8 -- 8 = SW1500
		 SWITCHER_0_6_0 = 9 -- 9 = 0-6-0 Switcher
		 SWITCHER_0_8_0 = 10-- 10 = 0-8-0 Switcher
		 H_9 = 11 -- 11 = 2-8-0 H-9 Consolidation
		 SW_9 = 12 -- 12 = SW-9
		 RS_3 = 13 -- 13 = Alco RS-3
		-- xx-255 TBD
	  --Railroad;   -- see below
		 UNKNOWN_RAILROAD = 0
		 P_AND_LE = 1
		 A_AND_S = 2
		 NYC = 3
		 B_AND_O = 4
		 P_AND_E = 5
		 LE_AND_E = 6
		 P_RR = 7
		 NH = 8
		 RDG = 9
         J_AND_L = 10
         Isalys = 11
         LV = 12
        -- Many more defined see "Tag Programmer"
	  --CarLength;  -- Length of car in centimeters, coupler face to coupler face (include Tender)
	  --TagOffset;  -- Distance from center of tag to coupler face in centimeters
						  -- for engines/cars with two tags, the distance must be same for both tags
	  --CarNumber[6];  -- Up to 6 digit engine/car number in ASCII (w/leading spaces) "  2808" -- NOT NULL TERMINATED
--[[---------------------------------------------------------------------------------------]]
-- The first six counters define the fields in the Program Control window that the Lua scripts can
-- increment (BumpCounter()), decrement (DecCounter()), read (GetCounter()) and clear (ClearCounter()).
-- Be careful if you change the TAGSUB, UNIQTAG or TAGCNT counters. These counters
-- are used by the tag detection system and changing them at the wrong time may confuse
-- the tag detection. Those counters appear on the Tags Detected List window.
-- The ELAPSEDTIME counter counts seconds and its probably not a good idea to change this value.
COUNTER01 = 0 -- User defined Counter 1
COUNTER02 = 1 -- User defined Counter 2
COUNTER03 = 2 -- User defined Counter 3
COUNTER04 = 3 -- User defined Counter 4
COUNTER05 = 4 -- User defined Counter 5
COUNTER06 = 5 -- User defined Counter 6
ELAPSEDTIME = 6   -- Elapsed Time Counter 7
TAGSUB = 10   -- The number of UID only tags detected that were replaced by tag data from previous tags
UNIQTAG = 11  -- The number of unique tags ever detected by your and previous scripts
TAGCNT = 12   -- The number of tags detected by your script
ENGINENO = 13	-- The value in the Engine Number spinner
--[[---------------------------------------------------------------------------------------]]
-- Beep() parameter
DEFAULT_BEEP = 0;
CRITICAL_STOP = 1;
QUESTION = 2;
EXCLAMATION = 3;
ASTERISK  = 4;

--[[---------------------------------------------------------------------------------------]]
-- LED colors for the SetLED() and other functions that require a color value
clGreen = 0;
clYellow = 1;
clRed = 2;
clClear = 3;
clBlack = 4;
clBlue = 5;
clFuchsia = 6;
--[[---------------------------------------------------------------------------------------]]
-- Packet Types
-- These numeric values are the different responses that RTC can receive
-- from the Detectors
-- Start of Packet Character
START_OF_PACKET = 0xFF
-- End of Packet Character
END_OF_PACKET = 0xF0

-- NOP - ACK - NAK - WACK
NOP = 0x00
ACK = 0x61
NAK = 0x62
WACK = 0x63

--Error:
--0x10 Didn't find PN53x detector on port X
PN53xNOTFOUND = 0x10
--0x11 Unable to read Block X
CANTREADBLOCK = 0x11
--0x12 Tag not Programmed
TAGNOTPROG = 0x12
--0x13 Unable to authenticate
AUTHERROR = 0x13
--0x14 SOP character missing
SOPMISSING = 0x14
--0x15 Write block error
WRITEERROR = 0x15
--0x16 No Tag Detected When Expected
NOTAGDETECTED = 0x16

--Tag Data (TAGDATABLOCK4 also returns the Tag UID):
--0x20 not used
--0x21 Block 4
TAGDATABLOCK4 = 0x21
--0x22 Block 5
TAGDATABLOCK5 = 0x22
--0x23 Block 6
TAGDATABLOCK6 = 0x23
--0x24 Block 7
TAGDATABLOCK7 = 0x24

--Information:
--0x01 Hello X RFID Readers Attached (RTCNFCIRQ version in Reader byte and TagCount byte)  
HELLOPACKET = 0x01
--0x03 Detector Y Reader X Detected
TAGDETECTED = 0x03
--0x04 Found chip PN5xx
PN53xFOUND = 0x04
--0x05 Waiting for an ISO14443A tag detection
WAITING = 0x05
--0x06 Detector Y Sensor X Detected
SENSORDETECTED = 0x06
--[[---------------------------------------------------------------------------------------]]
-----------------------------------------------------------------------------
-- Program constants
-----------------------------------------------------------------------------
-- These constants match constants in the Program Control code in RTC
-- They must not be changed
--[[-------------------------Direction-------------------------------------]]
WB = 1;
EB = 2;
DirectionNames = {
	"WB",
	"EB",
	};
--[[----------------------Block Occupancy----------------------------------]]
CLR = 0;  -- Clear
--OCC = 1;  -- Occupied is any value greater than 0
--[[------------Signals on the Program Control Cab Display-----------------]]
HOMESIGNAL = 0;
DISTANTSIGNAL = 1;
--[[-----------------------Aspect Names------------------------------------]]
AspectNames = {
	"None",		-- [1]
	"Dark",		-- [2], etc 
	"Stop Signal", 
	"Clear", 
	"Stop and Proceed", 
	"Approach", 
	"Medium Clear",
	"Medium Approach", 
	"Slow Clear", 
	"Slow Approach", 
	"Approach Medium", 
	"Approach Slow",
	"Restricting", 
	"Approach Limited", 
	"Limted Clear", 
	"Limited Approach",
	"Medium Approach Slow",	--[17]
	};

-- Aspect Selection
AsNone = 1;					-- Invalid Aspect or the Signal does not exist
AsDark = 2;					-- All Lights Off
AsStopSignal = 3;			-- Rule 292 without Number Plate or with 'A' on Number Plate
AsClear = 4;				-- Rule 281
AsStopandProceed = 5;		-- Rule 291 with Number Plate
AsApproach = 6;				-- Rule 285
AsMediumClear = 7;			-- Rule 283
AsMediumApproach = 8;		-- Rule 286
AsSlowClear = 9;			-- Rule 287
AsSlowApproach = 10;		-- Rule 288
AsApproachMedium = 11;		-- Rule 282
AsApproachSlow = 12;		-- Rule 284
AsRestricting = 13;			-- Rule 290
AsApproachLimited = 14;		-- Rule 281 (B)
AsLimitedClear = 15;		-- Rule 281 (C)
AsLimitedApproach = 16;		-- Rule 281 (D)
AsMediumApproachSlow = 17;	-- Rule 283 (B)
AsLast = 18;				-- last valid Aspect + 1

-- Signal Head Types
Hd3Light = 3
Hd2Light = 2
Hd1Light = 1
HdNone = 0

-- Signal Types
UNDEFINED_SIGNAL_TYPE = 0;
PERMISSIVE_IN_OPEN_COUNTRY = 1;
ABSOLUTE_HEAD_BLOCK = 2;
PERMISSIVE_HEAD_BLOCK = 3;
APPROACH_TO_HEAD_BLOCK = 4;
--[[---------------------------------------------------------------------------------------]]
--[[
	Copyright (c) 2016 Scott Lembcke and Howling Moon Software
	
	Permission is hereby granted, free of charge, to any person obtaining a copy
	of this software and associated documentation files (the "Software"), to deal
	in the Software without restriction, including without limitation the rights
	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	copies of the Software, and to permit persons to whom the Software is
	furnished to do so, subject to the following conditions:
	
	The above copyright notice and this permission notice shall be included in
	all copies or substantial portions of the Software.
	
	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	SOFTWARE.
	
	TODO:
	* Print short function arguments as part of stack location.
]]
function Pretty(obj, max_depth)
	if max_depth == nil then max_depth = 10 end
	
	-- Returns true if a table has a __tostring metamethod.
	local function coerceable(tbl)
		local meta = getmetatable(tbl)
		return (meta and meta.__tostring)
	end
	
	local function recurse(obj, depth)
		if type(obj) == "string" then
			-- Dump the string so that escape sequences are printed.
			return string.format("%q", obj)
		elseif type(obj) == "table" and depth < max_depth and not coerceable(obj) then
			local str = "{"
			
			for k, v in pairs(obj) do
				local pair = Pretty(k, 0).." = "..recurse(v, depth + 1)
				str = str..(str == "{" and pair or ",\n "..pair)
			end
			
			return str.."}"
		else
			-- tostring() can fail if there is an error in a __tostring metamethod.
			local success, value = pcall(function() return tostring(obj) end)
			return (success and value or "<!!error in __tostring metamethod!!>")
		end
	end
	
	return recurse(obj, 0)
end
PrettyPrint = function(value, depth) print(Pretty(value, depth)) end

--[[
---------------------------------------------------------------------------
Remote Train Control Program for Windows

© Copyright 2021 by Mark DiVecchio

	This file is part of Remote Train Control.

	Remote Train Control is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	Remote Train Control is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with Remote Train Control.  If not, see <http://www.gnu.org/licenses/>.

 Home Page : http://www.silogic.com/trains/RTC_Running.html
---------------------------------------------------------------------------]]

-- Semicolons are not required in Lua code

function isEngine(EngNo)
	if (EngNo > 0) then return true; end
	return false;
	end
	
function notEngine(EngNo)
	if (EngNo == 0) then return true; end
	return false;
	end	
	
function isTagRear(TagLocation)
	if (TagLocation == TAG_ON_REAR_TRUCK) then return true; end
	return false;
	end

function isTagFront(TagLocation)
	if (TagLocation == TAG_ON_FRONT_TRUCK) then return true; end
	return false;
	end
	
function isDetector(Detector, x)
	if (Detector == x) then return true; end
	return false;
	end	
	
function isReader(Reader, x)
	if (Reader == x) then return true; end
	return false;
	end	
	
function isCarModel(CarModel, x)
	if (CarModel == x) then return true; end
	return false;
	end	

--[[---------------------------------------------------------------------------------------
Occupancy Flags are supported as part of the Thinking Engines project.
Up to 100 flags are available to indicate block occupancy. A Zero value
means the block is unoccupied. A non zero value means the block is occupied.
-- returns two values
-- 1: true on success, false on failure
-- 2: on failure, the block numbers that would not lock, otherwise 0
-- Wait is the number of seconds to wait, default to 1200 (20 minutes)
When occupied, the Flag should be set to the engine number of the engine
in the block.
]]
--[[---------------------------------------------------------------------------------------]]
-- Set a value into the block occupancy flag
-- Waits 'forever' for the block to show as unoccupied before it sets occupancy
function SetOccupancy(block, value, Wait)
if (block < FIRST_BLOCK or block > LAST_BLOCK) then
	return Stop("Invalid Block Number in SetOccupancy()");
	end;
if (value == 0) then
	return Stop("Value in SetOccupancy() is zero, use ClearOccupancy() instead");
	end;
local WaitTime = Wait or 1800;	-- let's say that 30 minutes is 'forever'
-- set the occupancy flag if it is zero or we already have ownership - use lock
while (not TrySetFlag(block, value)) do
	-- wait 'forever'
	if (((WaitTime >> 1) % 10) == 0) then
		print("Waiting for " .. BlockName[block] .. " to clear");
		end;
	Sleep(2);
	WaitTime = WaitTime - 2;
	if (WaitTime <= 0) then
		printc(clRed,"SetOccupancy() Timed out waiting for " .. BlockName[block] .. " to clear"); 
		return false, block;
		end	
	end;
print("Set occupancy flag on " .. BlockName[block] .. " to " .. value);
return true;
end;
--[[---------------------------------------------------------------------------------------]]
-- Tries to set a value into the block occupancy flag
-- Only tries once. Returns true on success, false if the block is occupied.
function TrySetOccupancy(block, value)
if (block < FIRST_BLOCK or block > LAST_BLOCK) then
	return Stop("Invalid Block Number in TrySetOccupancy()");
	end;
if (value == 0) then
	return Stop("Value in TrySetOccupancy() is zero, use ClearOccupancy() instead");
	end;
-- set the occupancy flag if it is zero or we already have ownership - use lock
if (not TrySetFlag(block, value)) then
	-- did not get a lock
	print("TrySetOccupancy() flag on " .. BlockName[block] .. " - could not get lock");
	return false;
	end;
print("TrySetOccupancy() flag on " .. BlockName[block] .. " to " .. value);
return true;
end;
--[[---------------------------------------------------------------------------------------]]
-- Clear a block occupancy flag to zero if we have ownership, that is,
    -- we are occupying the block.
function ClearOccupancy(block, value)
if (block < FIRST_BLOCK or block > LAST_BLOCK) then
	return Stop("Invalid Block Number in ClearOccupancy()");
	end;
if (value ~= nil and GetFlag(block) == value) then
	print("ClearOccupancy() flag on " .. BlockName[block]);
	SetFlag(block, 0);
	end;
return true;
end;
--[[---------------------------------------------------------------------------------------]]
-- set a block occupancy flag without waiting for lock or checking ownership
-- Can be very dangerous if your script makes a mistake.
function OverrideOccupancy(block, value)
if (block < FIRST_BLOCK or block > LAST_BLOCK) then
	return Stop("Invalid Block Number in OverrideOccupancy()");
	end;
if (value == nil) then
	value = 0;
	end;
print("OverrideOccupancy() flag on " .. BlockName[block] .. " to " .. value);
SetFlag(block, value);
return true;
end;
--[[---------------------------------------------------------------------------------------]]
-- fetch a block occupany flag
function GetOccupancy(block)
if (block < FIRST_BLOCK or block > LAST_BLOCK) then
	return Stop("Invalid Block Number in GetOccupancy()");
	end;
return GetFlag(block);
end;
--[[---------------------------------------------------------------------------------------]]
-- Set a value into several block occupancy flags. All blocks must be unoccupied.
-- Waits almost forever for the blocks to show as unoccupied before it sets occupancy
-- Returns two values
-- 1: true on success, false on failure
-- 2: on failure, one of the block numbers that would not lock, otherwise 0
-- Wait is the number of seconds to wait, default to 600 (10 minutes)
-- blocks is a table of the form {2, 44, 21}
function MultiSetOccupancy(blocks, value, Wait)
if (type(blocks) ~= "table") then return Stop("MultiSetOccupancy() block not a table"), 0; end
-- loop through all blocks in table
for k, v in ipairs(blocks) do
	if (v < FIRST_BLOCK or v > LAST_BLOCK) then
		return Stop("Invalid Block Number in MultiSetOccupancy()"), 0;
		end;
	end;
if (value == 0) then
	return Stop("Value in MultiSetOccupancy() is zero, use ClearOccupancy() instead"), 0;
	end;
local WaitTime = Wait or 1800;	-- let's say 30 minutes is 'forever'
-- set the occupancy flag if it is zero or we already have ownership - use lock
local occupiedblock;
while (true) do
	local result;
	result, occupiedblock = TryMultiSetFlag(blocks, value)
	if (result) then
		break;
		end;
	-- wait almost forever
	if (((WaitTime >> 1) % 10) == 0) then
		print("MultiSetOccupancy() Waiting for " .. BlockName[occupiedblock] .. " to clear");
		end;
	Sleep(2);
	WaitTime = WaitTime - 2;
	if (WaitTime <= 0) then
		printc(clRed,"MultiSetOccupancy() Timed out waiting for " .. BlockName[occupiedblock] .. " to clear"); 
		return false, occupiedblock;
		end
	end;
-- loop through all blocks in table
for k, v in ipairs(blocks) do
	print("MultiSetOccupancy() flag on " .. BlockName[v] .. " to " .. value);
	end;
return true, 0;
end;
--[[---------------------------------------------------------------------------------------]]
-- Set a value into several block occupancy flags. All blocks must be unoccupied.
-- Only tries once
-- returns two values
-- 1: true on success, false on failure
-- 2: on failure, the block number that would not lock, otherwise 0
function TryMultiSetOccupancy(blocks, value)
-- blocks is a table of the form {2, 44, 21}
if (type(blocks) ~= "table") then return Stop("TryMultiSetOccupancy() block not a table"); end
for k, v in ipairs(blocks) do
	if (v < FIRST_BLOCK or v > LAST_BLOCK) then
		return Stop("Invalid Block Number in TryMultiSetOccupancy()"), 0;
		end;
	end;
if (value == 0) then
	return Stop("Value in TryMultiSetOccupancy() is zero, use ClearOccupancy() instead"), 0;
	end;
-- set the occupancy flag if it is zero or we already have ownership - use lock
local success, occupiedblock = TryMultiSetFlag(blocks, value);
if (not success) then
	-- did not get a lock
	print("TryMultiSetOccupancy() flag on " .. BlockName[occupiedblock] .. " - could not get lock");
	return false, occupiedblock;
	end;
-- loop through all blocks in table
for k, v in ipairs(blocks) do
	print("TryMultiSetOccupancy() flag on " .. BlockName[v] .. " to " .. value);
	end;
return true, 0;
end;
--[[---------------------------------------------------------------------------------------]]
-- Set a value into one of several block occupancy flags
-- Waits almost forever for one of the blocks to show as unoccupied before it sets occupancy
-- returns two values
-- 1: true on success, false on failure
-- 2: on success, the block number that locked, otherwise 0
-- Wait is the number of seconds to wait, default to 600 (10 minutes)
-- blocks is a table of the form {2, 44, 21} or {2}
function SingleSetOccupancy(blocks, value, Wait)
if (type(blocks) ~= "table") then return Stop("SingleSetOccupancy() block not a table"), 0; end
-- loop through all blocks in table
for k, v in ipairs(blocks) do
	if (v < FIRST_BLOCK or v > LAST_BLOCK) then
		return Stop("Invalid Block Number in SingleSetOccupancy()"), 0;
		end;
	end;
if (value == 0) then
	return Stop("Value in SingleSetOccupancy() is zero, use ClearOccupancy() instead"), 0;
	end;
local WaitTime = Wait or 1800;	-- let's say that 30 minutes is 'forever'
-- set the occupancy flag if it is zero or we already have ownership - use lock
local occupiedblock;
while (true) do
	for k,v in ipairs(blocks) do
		-- lock the first block that becomes available
		local result = TrySetFlag(v, value)
		if (result) then
			occupiedblock = v;
			print("SingleSetOccupancy() flag on " .. BlockName[occupiedblock] .. " to " .. value);
			return true, occupiedblock;
			end;
		if (((WaitTime >> 1) % 10) == 0) then
			print("SingleSetOccupancy() Waiting for " .. BlockName[v] .. " to clear");
			end;
		end;
	-- wait almost forever
	Sleep(2);
	WaitTime = WaitTime - 2;
	if (WaitTime <= 0) then
		break;
		end		
	end;

	for k,v in ipairs(blocks) do
		printc(clRed,"SingleSetOccupancy() Timed out waiting for " .. BlockName[v] .. " to clear"); 
		end;

return false, 0;
end;
--[[---------------------------------------------------------------------------------------]]
function WaitforStopSignaltoClear()
local Aspect = (GetCabAspect(HOMESIGNAL));
-- check that home signal is not AsStopSignal, if it is, we MUST Stop until it clears
if (Aspect == AsStopSignal) then
	-- we are stopped, so wait until the Stop Signal aspect is cleared.
	print("WaitforStopSignaltoClear : Home Signal aspect is Stop Signal. Wait for it to clear before proceeding.");
									-- wait for Stop Signal to clear
	local WaitTime = 1800;	-- let's say that 30 minutes is 'forever'
	-- Wait for the signal to changed from Stop Signal
	while (Aspect == AsStopSignal) do
		-- wait 'forever'
		if (((WaitTime >> 1) % 10) == 0) then
			print("WaitforStopSignaltoClear : Waiting for Stop Signal to clear");
			end;
		Sleep(2);
		WaitTime = WaitTime - 2;
		if (WaitTime <= 0) then
			return Stop("WaitforStopSignaltoClear : Timed out waiting for Stop Signal to clear"); 
			end;
		Aspect = (GetCabAspect(HOMESIGNAL));
		end;
	end;
end;
--[[---------------------------------------------------------------------------------------]]

	

-- Semicolons are not required in Lua code
title = "Lashup Startup/Shutdown Test"
require("defines");

local MyEngineNo, MyLashUpNo, MyTIUNo;

--[[---------------------------------------------------------------------------------------]]
function setup(Engine, TIU)
	print("setup()");
	MyTIUNo = TIU;
	MyLashUpNo = 101;
	AIUNo = 1;
	return true;		-- false=setup failed, true=setup succeeded
	end
--[[---------------------------------------------------------------------------------------]]
function loop(Engine, TIU)
	print("loop()");

	LashUpEngineList = {};
	EngineIndex = 1;
	LashUpEngineList[EngineIndex] = 9;									-- head engine P&LE SW1500#1556
	EngineIndex = EngineIndex + 1; LashUpEngineList[EngineIndex] = 13;	-- middle engine P&LE GP7 #1500
	EngineIndex = EngineIndex + 1; LashUpEngineList[EngineIndex] = -8;	-- tail engine reverse running P&LE MP15AD#1594
	print("LashUp :");
	for i,v in ipairs(LashUpEngineList) do 
		print(string.format("     Engine %d", v));
		end
		
	print("Startup");
	retv = StartUp(0, MyLashUpNo, LashUpEngineList, MyTIUNo);
	if (retv == nil) then print("Startup failed"); end;
	Sleep(15);		-- engines take time to startup

	print("Smoke Off");
	retv = Smoke(OFF, 0, MyLashUpNo, MyTIUNo);
	if (retv == nil) then print("Smoke Off Failed"); end;
	
	print("Whistle On");
	retv = Whistle(ON, 5, MyLashUpNo, MyTIUNo);
	if (retv == nil) then print("Whistle On failed"); end;
	Sleep(2);
	
	print("Whistle Off");
	retv = Whistle(OFF, 5, MyLashUpNo, MyTIUNo);
	if (retv == nil) then print("Whistle Off failed"); end;
	Sleep(15);
	
	print("Bell On");
	retv = Bell(ON, 5, MyLashUpNo, MyTIUNo);
	if (retv == nil) then print("Bell On failed"); end;
	Sleep(2);
	
	print("Bell Off");
	retv = Bell(OFF, 5, MyLashUpNo, MyTIUNo);
	if (retv == nil) then print("Bell Off failed"); end;
	Sleep(15);
	
	print("SetSpeed");
	retv = SetSpeed(10, 0, MyLashUpNo, MyTIUNo);
	if (retv == nil) then print("SetSpeed failed"); end;
	Sleep(20);	

	return Stop();	-- false=do not loop, true=continue to loop
	end
--[[---------------------------------------------------------------------------------------]]
function cleanup(Engine, TIU)
	-- this function is called once when the user presses the [STOP] button
	print(os.date("cleanup()  %d %b %Y   %X"));

	print("SetSpeed");
	retv = SetSpeed(0, 0, MyLashUpNo, MyTIUNo);
	if (retv == nil) then print("SetSpeed failed"); end;
	Sleep(10);
		
	print("Shutdown");
	retv = Shutdown(0, MyLashUpNo, MyTIUNo);
	if (retv == nil) then print("Shutdown failed"); end;

	print("Feature Reset");
	for i,v in ipairs(LashUpEngineList) do 
		print(string.format("Feature Reset & Smoke Off - Engine %d", v));
		FeatureReset(math.abs(v), MyTIUNo);
		Smoke(OFF, 0, math.abs(v), MyTIUNo);	-- Feature reset turns Smoke on
		end
		
	print("Done!");
	return true;		-- false=cleanup failed, true=cleanup succeeded
	end
--[[---------------------------------------------------------------------------------------]]

-- Semicolons are not required in Lua code
title = "Event Test"
require([[defines]]);
require([[functions]]);

--[[---------------------------------------------------------------------------------------]]
function setup(Engine, TIU)
	print("setup() Running");
	print("This is Program Control Window #" .. PCNo());
	print("This script requires 'event.lua' be running in PC window #1 and #2");
	if (PCNo() < 1 or PCNo() > 2) then
		return false;	-- need two PC windows 1 and 2
		end
	return true;		-- false=setup failed, true=setup succeeded
	end
--[[---------------------------------------------------------------------------------------]]
function loop(Engine, TIU)
	-- Always call Sleep(X) at least once in this function if it returns true;
	print("loop() Running");
	if (PCNo() == 1) then
		DestPC = 2;
		end;
	if (PCNo() == 2) then
		DestPC = 1;
		end
	print("Sending an event to PC Window #" .. DestPC .. " in 10 seconds");
	Sleep(10);
	res = SetEvent(DestPC, 123456789012345, PCNo(), -876765, 556677);
	if (type(res) ==  "nil") then
		print("nil : invalid destination Program Control number - script not running");
		return Stop("DONE");
		end;
	if (type(res) == "boolean") then
		print(res, " : success");
		end;
	print("Almost Done...");
	Sleep(10);
	return Stop("DONE");
	end
--[[---------------------------------------------------------------------------------------]]
function event(FromPC, Type, P1, P2, P3)
print("event() - From PC# ", FromPC, " EventType = ", Type, " Parameters = ", P1, " ", P2, " ", P3);
	return true;		-- false=event failed, true=event succeeded	
	end

--[[---------------------------------------------------------------------------------------]]
function cleanup(Engine, TIU)
	-- this function is called once when the user presses the [STOP] button
	print("cleanup() Running");
	return true;		-- false=cleanup failed, true=cleanup succeeded
	end
--[[---------------------------------------------------------------------------------------]]

-- Semicolons are not required in Lua code
title = "Global Variables Test"
require("defines");
require("functions");

--[[---------------------------------------------------------------------------------------]]
function setup(Engine, TIU)
	-- this function is called once when the [Run Script] button is pushed
	-- Engine : Engine number selected on the RTC Main window
	-- TIU : TIU number selected on the RTC Main window
	print("setup()");
	for x = 1, 15 do
		SetGlobalInt(x, 0);
		print("GetGlobalInt(" .. x .. ") (zero) = ", GetGlobalInt(x))
		end;
	SetGlobalInt(3, 23456);
	SetGlobalInt(99, 33);
	
	if (GetGlobalInt(3) ~= 23456) then
		print("Global Int 3 not set correctly (23456)");
		end;
	if (GetGlobalInt(99) ~= 33) then
		print("Global Int 99 not set correctly (33)");
		end;
	
	SetGlobalString(4, "My String");
	if (GetGlobalString(4) ~= "My String") then
		print('Global String 4 not set correctly ("My String")');
		end;

	-- RunTime() must be converted to an integer
	SetGlobalString(8, string.format("The time is %d seconds", math.floor(RunTime() + 0.5)));
		
	print(string.format("RunTime = %.2f seconds", RunTime()));
	return true;		-- false=setup failed, true=setup succeeded
	end
--[[---------------------------------------------------------------------------------------]]	
function loop(Engine, TIU)
	-- must call Sleep() at least once in this function
	print("loop()");
	print("GetGlobalInt(3) (23456) = ", GetGlobalInt(3));
	GlobalInt99 = GetGlobalInt(99);
	print("GetGlobalInt(99) (++) = ", GlobalInt99);
	GlobalInt99 = GlobalInt99 + 1;
	SetGlobalInt(99, GlobalInt99);
	
	if (GetGlobalInt(3) ~= 23456) then
		print('Global Int 3 not set correctly ("23456")');
		end;
	if (GetGlobalInt(99) ~= GlobalInt99) then
		print("Global Int 99 not set correctly (" .. GlobalInt99 .. ")");
		end;
	
	SetGlobalString(4, "My String");
	if (GetGlobalString(4) ~= "My String") then
		print('Global String 4 not set correctly ("My String")');
		end;

	print("GetGlobalString(4) ('MyString') = ", GetGlobalString(4));
	print("GetGlobalString(8) = ", GetGlobalString(8));
	--print("GetGlobalString(11) = ", GetGlobalString(11));	-- gets "index out of range" error	
	for x = 1, 15 do
		print("GetGlobalInt(" .. x .. ") = ", GetGlobalInt(x))
		end;
	Sleep(5);
	SetGlobalString(8, string.format("The time is %d seconds", math.floor(RunTime() + 0.5)));
	print("loop exit");	
	return true;		-- false=loop failed, true=loop succeeded
	end
--[[---------------------------------------------------------------------------------------]]
function cleanup(Engine, TIU)
	-- this function is called once when the user presses the [STOP] button
	print(string.format("cleanup() Complete at %.2f", RunTime()));
	return true;		-- false=cleanup failed, true=cleanup succeeded
	end
--[[---------------------------------------------------------------------------------------]]