MagEc.lua

-- Eclipse Magic
-- Programmed exposure sequence for a solar eclipse (35mm Huluchuan)


-- Eclipse Magic
--
-- Version 1.7.1
--
-- Copyright 2017 by Brian Greenberg, grnbrg@grnbrg.org.
-- Distributed under the GNU General Public License.
-- Modified by Boyang Liu in 2019.
--
-- ***************************************************************************************************
-- ***************************************************************************************************
--
-- **NOTE** At the current time, the "camera.burst()" functionality requires the "lua_fix"
-- beta build of Magic Lantern which can be found at https://builds.magiclantern.fm/experiments.html.
-- Hopefully this function will be merged into the mainline soon.
--
-- ***************************************************************************************************
-- ***************************************************************************************************
--
--
-- Read through the comments at the top of the script, and modify the contact points to suit
-- your location, and the exposure settings to suit your camera.  Copy the script to
-- the ML/SCRIPTS directory on your camera's media, and run it from the menu.
--
-- If you have issues, (and you aren't running with the test flag set) you should be able to
-- reboot your camera, and it will pick up where it left off.  Exposure events are tied to
-- particular times, not a sequence that needs to start at a specific time.  This is useful if
-- (for example) you need to change batteries in mid-eclipse.
--
-- See http://xjubier.free.fr/en/site_pages/SolarEclipseExposure.html for suggestions for
-- exposure values.
--
-- The previously released 1.5.0 version of this script can be found at:
--
--		http://www.grnbrg.org/eclipse_magic-1.5.0.lua
--
--
-- If this script is useful, feel free to send a PayPal donation to Eclipse-Magic@grnbrg.org,
-- or a Bitcoin donation to 1grnbrg3Ea4t6bxHvQKRvorbBeLNDXv2N.
--
-- ***************************************************************************************************
-- ***************************************************************************************************
-- ***************************************************************************************************

require ("logger")

-- Variable definitons that have to go here.  Ignore them.
c1 = {}
c2 = {}
c3 = {}
c4 = {}

--
--  If you are testing, set this to 1, and the shutter won't be used.
--  Set it to 0 for the real event.
--
--  This changes how the contact times are interpreted!  If TestBeepNoShutter
--  is set to 1, then the contact times are time elapsed after the script is started.
--  it is set to 0, then the contact times reference the realtime clock of the camera.
--
--  For example:
--
--  If C1 is set to 10:30:00 (ie: 10:30:00 am), and the current time on the camera is set
--  to 08:00:00 (ie: 8:00:00 am), then
--
--  If TestBeepNoShutter is set to 1, then the script will start demonstrating eclipse exposures
--  in ten hours and thirty minutes.
--
--  If TestBeepNoShutter is set to 0, the script will start taking actual exposures in two
--  hours and thirty minutes (ie: at 10:30:00).
--
--  The intent was that (for testing) you could set C1 to 00:00:30 or so, and the other contacts to
--  similar offsets, and not worry about messing with the clock on the camera.  (This may not have
--  been the best choice on my part!  :) )
TestBeepNoShutter = 0

--
-- Send log information (essentially everything shown on the screen) to a file (ECLIPSE.LOG) at the
-- top directory of the camera card.  Useful for testing.
--
LogToFile = 1
LoggingFile = nil

--
-- Set the 4 contact times here.  Time zone is irrelevant, as long as your camera and these
-- times are the same.  Make sure the times are correct for your location, and that your camera
-- is accurately set to GPS time.
--
-- below line: revised from 1 to 0 by boyangliu 20190305. number must be in INTERGER
if ( TestBeepNoShutter == 0 )
then
	-- La Silla (UTC-4): 15:23:51.1 16:39:24.3 16:41:15.6 17:47:16.7
	c1.hr = 15; c1.min = 23; c1.sec = 51;
	c2.hr = 16; c2.min = 39; c2.sec = 24;
	c3.hr = 16; c3.min = 41; c3.sec = 16;
	c4.hr = 17; c4.min = 47; c4.sec = 17;
else
	-- Testing:
	c1.hr = 0; c1.min =  0; c1.sec = 10;
	c2.hr = 0; c2.min =  1; c2.sec = 10;
	c3.hr = 0; c3.min =  3; c3.sec = 1;
	c4.hr = 0; c4.min =  4; c4.sec = 1;
end


-- Set an aperture value.  The script assumes that the aperture stays constant throughout the
-- eclipe.  The camera will (try to) set this aperture (f-number) at the beginning of the script.
-- Useful, as it is easy to forget this, if you are shooting with a regular camera lens.
-- If the script and camera are being used with a fixed aperture lens (or telescope), then
-- set the "SetAperture" to 0.
SetAperture = 1
Aperture1 = 8.0
Aperture2 = 4.0

--
-- If you shoot with LiveView active, you will reduce the amount of mirror slap, giving
-- less vibration.  But.  Some cameras (Such as the 5DmkII.) have a limited range of shutter
-- speed when LV and Movie mode are enabled.  This reduces the available speeds from 30 seconds
-- through 1/8000th of a second to 1/30th to 1/4000th of a second.  Exceeding that range while
-- LV and Movie mode are enabled will crash the script.
--
-- Setting this variable to 1 will, before taking any images, check if LV is running, and if it
-- is, will tell you to turn it off.  If you have disabled movie mode (A menu option on some cameras,
-- like the 5DmkII, and a hardware switch on others) you should set this to 0.
--
-- Test your camera.  If the exposure speeds you want crash the script in LV, check how to disable
-- movie mode.
--
WarnLiveView = 0

--
-- Set this variable to 1 will force the camera to go to LV mode before each shot.
--
ForceLiveView = 1

--
-- If you're shooting in Live View (to reduce mirror slap) you'll probably still want to check
-- your focus occasionally.  However, the status display of the script pretty much fills the screen,
-- making this difficult.  Enabling HideConsole will display the console for the indicated number
-- of seconds both before and after the next shutter event, and turn the console off between.  This
-- also gives you an idea of how much time you have before the next shutter event -- if the console
-- is hidden, you have at least ConsoleShowDelay seconds to mess around.  If you turn this off, the
-- script will start with the console displayed, and you will have to manage it through the Magic
-- Lantern menu.  If you turn it off, it stays off until you turn it on again.
--
HideConsole = 1
ConsoleShowDelay = 10


--
-- Even if you shoot with Live View with Silent Mode 1 (which forces the mirror to be
-- locked up, and eliminates the vibration from the shutter opening) there will be slight
-- vibrations introduced as the shutter closes.  According to Jerry Lodriguss at
-- http://www.astropix.com/wp/2017/07/17/mirror-slap-and-shutter-shock/ these vibrations
-- are most prominent between 1/125s and 2s, and can be somewhat mitigated by a slight
-- delay before exposure, to allow the vibration to dampen a bit.
--
-- Enabling this option lets you set a range of shutter speeds to delay before, and
-- how long (in milliseconds) to pause.
--
DoShutterShockDelay = 0
SlowestDelayedShutter = 2
FastestDelayedShutter = (1/125)
ShutterShockDelayMS = 500		-- Value is in milliseconds!


--
-- Partial phase settings.
--
PartialISO = 100
PartialShutterSpeed = (1/16)
PartialMarginTime = 15			-- Number of seconds after C1 or C3 and before C2 or C4 to start exposures
PartialExposureCount = 150		-- Number of partial phase exposures before and after totality
PartialDoBkt = 1				-- Do you want to do exposure bracketing?  1 - yes, 0 - no
PartialBktStep = 8				-- Number of f-stops in each step.  Can 0.333333, 1, 2, etc
PartialBktCount = 1				-- How many brackets on each side of the neutral exposure?


--
-- Optionally enable high speed burst mode
--
-- As originally written, the script used the camera.burst() function, to take a burst of
-- images as quickly as possible, as though the shutter button was held down.  This had two issues:
-- The first being that the buffer in the camera fills after around 2-3 seconds when shooting
-- RAW, and then slows drastically, and the second being that once called, the camera will take
-- exposures until the requested number of images are captured, and if the buffer fills, this may
-- take considerably longer than expected.
--
-- I have (by default) replaced this function with a burst function that tries to take a given number
-- of images over a set period of time, each with a single shutter release call.  This is much slower
-- (two or three frames per second, tops) but therefor fills the buffer more slowly, and allows the script
-- to abort the burst (and take fewer than the requested number of images) if the capture runs past the
-- specified time limit.
--
-- If you prefer the old high speed burst call, set this variable to 1.
--
UseBurst = 0

--
-- Do a fast burst of exposures at C2 and C3, to try to get Baily's beads and chromosphere.
-- You will need to know how many exposures your camera will buffer, and how long it takes the
-- buffer to fill.  At "StartOffset" seconds before C2 or C3, the camera will take "BurstCount"
-- exposures, as fast as it can.  You should adjust C23StartOffset so that burst of image straddles
-- the contact time.  Note that, between the setting of the camera clock and the jitter in this
-- script, there will be some error in the timing.  +/- half a second or more is possible.
--
C23BurstCount = 10			-- Note that most Canon DSLRs can't take more than 13-14 RAW images
								-- in a burst before the buffer is full, and they slow to ~1 image/second.
C2BurstStartOffset = 6
C2BurstTime = 10
C3BurstStartOffset = 4
C3BurstTime = 10
C23BurstISO = 100
C23BurstShutterSpeed = (1/3200)

--
-- Do a fast burst of exposures before C2 and after C3, to try to get the diamond ring.
--
-- Be careful setting the RingStartOffset, Count and Time.  If the burst of images for the
-- pre-C2 rings runs longer than expected, it can cause the pre-C2 Baily's Beads exposures to
-- be skipped.
--
-- The post-C3 Rings exposures (if enabled) will run immediately after the post-C3 Baily's Beads
-- exposures.
--
DoRing = 0		-- Are we going to try for a burst for the diamond ring?
RingStartOffset = C2BurstStartOffset + 5  -- How long before C2/after C3 to start?  Be careful that
												-- this does not interfere with the Baily's burst!
RingBurstCount = 8  -- How many images?
RingBurstTime = 4	-- If we're doing a manual burst, how long should it last?
RingBurstISO = 100
RingBurstShutterSpeed = 1/30


--
-- During the time between C2 and C3, the script will run back and forth between the
-- "MinShutterSpeed" and "MaxShutterSpeed" as quickly as possible, with an extra 2 long exposures
-- at midpoint.  "ExpStep" is the size of the f-stop variation, and can be set to 0.333333, 1, 2, etc.
-- Min, Max and PrefISO:  Totality exposures will run (where possible) at PrefISO.  However, there
-- will also be exposures at MinShutterSpeed from MinISO to PrefISO, and MaxShutterSpeed from
-- PrefISO to MaxISO.
--
TotalityMinISO = 100
TotalityMaxISO = 100
TotalityPrefISO = 100
TotalityMinShutterSpeed = (1/1250) -- (MinShutterSpeed is the *fastest* speed to use.)
TotalityMaxShutterSpeed = 2 -- (MaxShutterSpeed is the *slowest*, longest speed used.)
TotalityExpStep = 1

--
-- One of the more difficult exposures to capture is earthshine -- the surface of the moon,
-- illuminated by light reflected from the earth.
--
-- The best time to do this is at the point of maximum eclipse, where the sun is centred behind
-- the moon, as much as possible.  Exposures here are kind of guesswork, and I have actually turned this
-- off by default.
--
DoMaxExposures = 0		-- Number of (possibly bracketed) exposures to take at max-eclipse.
MaxOffset = (10) 		-- How long before max eclipse to start these exposures.  You'll have to test
						-- or use math to determine this value.  (Value is in seconds.)
NumMaxExposures = 1
DoMaxBrackets = 1		-- Brackets?
NumMaxBrackets = 1
MaxBracketStep = 1
MaxISO = 100
MaxShutterSpeed = 1.25

---------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------
--
--                                       HERE THERE BE DRAGONS
--
---------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------

--
-- Times are easiest to deal with in seconds.  This would be painful if they crossed over midnight,
-- but late-night solar eclipses are rare.
--
c1_sec = c1.hr * 3600 + c1.min * 60 + c1.sec
c2_sec = c2.hr * 3600 + c2.min * 60 + c2.sec
c3_sec = c3.hr * 3600 + c3.min * 60 + c3.sec
c4_sec = c4.hr * 3600 + c4.min * 60 + c4.sec
max_sec = math.floor(c2_sec + ((c3_sec - c2_sec) / 2))

MaxOffset = MaxOffset * DoMaxExposures -- This is ugly, and shouldn't be here.

tick_offset = 0
TestStartTime = 0

--
-- Log to stdout and optionally to a file
--
function log (s, ...)
	local str = string.format (s, ...)
	str = str .. "\n"
	if (LogToFile == 0 or LoggingFile == nil)
	then
		io.write (str)
	else
		LoggingFile:write (str)
	end
	return
end

--
-- Open log file
--
function log_start ()
	if (LogToFile ~= 0)
	then
		local cur_time = dryos.date
		-- Opening logger with long filename fails. Works with short name.
		--local filename = string.format("eclipse_%04d%02d%02d_%02d%02d%02d.log", cur_time.year, cur_time.month, cur_time.day, cur_time.hour, cur_time.min, cur_time.sec)
		local filename = string.format("eclipse.log")
		print (string.format ("Open log file %s", filename))
		LoggingFile = logger (filename)
	else
		print (string.format ("Logging not configured"))
	end
end

--
-- Close log file
--
function log_stop ()
	if (LogToFile ~= 0)
	then
		print (string.format ("Close log file"))
		LoggingFile:close ()
	end
end

--
-- Get the current time (in seconds) from the camera's clock.
--
function get_cur_secs ()

	local cur_time = dryos.date
	local cur_secs = (cur_time.hour * 3600 + cur_time.min * 60 + cur_time.sec)

	if ( TestBeepNoShutter == 1 )
	then

		cur_secs = (cur_secs - TestStartTime)		-- If we're testing, start the clock at
													-- now, not actual time.

	end

	return cur_secs

end


--
-- Take a time variable expressed in seconds (which is what all times are
-- stored as) and convert it back to HH:MM:SS
--
function pretty_time (time_secs)

	local text_time = ""
	local hrs = 0
	local mins = 0
	local secs = 0

	hrs =  math.floor(time_secs / 3600)
    mins = math.floor((time_secs - (hrs * 3600)) / 60)
	secs = (time_secs - (hrs*3600) - (mins * 60))

	text_time = string.format("%02d:%02d:%02d", hrs, mins, secs)

	return text_time

end


--
-- Take a shutter speed expressed in (fractional) seconds and convert it to 1/x.
--
function pretty_shutter (shutter_speed)

	local text_time = ""
	if (shutter_speed >= 1.0)
	then
		text_time = tostring (shutter_speed)
	else
		text_time = string.format ("1/%s", tostring (1/shutter_speed))
	end
	return text_time

end


--
-- Hurry up and wait for the next important time to arrive.
--
-- Leave the console displayed for 60 seconds at the start and end of
-- a wait.  Turn it off between, so that tracking can be done via live view, etc.
--
function wait_until (done_waiting)

	local counter = get_cur_secs()
	local next_sec = 0
	local show_console = ConsoleShowDelay
	local console_visible = 1

	console.show()

	log ("Waiting for %s in %d seconds.", pretty_time(done_waiting), done_waiting - counter)

	repeat

		task.yield (1000) -- Let the camera do other tasks for a second.

		if ((HideConsole == 1) and (show_console > 0))
		then

			show_console = show_console -1

		elseif ((HideConsole == 1) and (show_console == 0))
		then

			console.hide()

			show_console = -1

			console_visible = 0

		end

		if ((HideConsole == 1) and ((done_waiting - counter) < 30 ) and (console_visible == 0))
		then

			console.show()

			console_visible = 1

		end

		counter = get_cur_secs()

	until (counter >= (done_waiting - 1))

	if ( counter < done_waiting)
	then
									-- Loop /should/ exit the second before we are done. But
									--  It's possible that it could exit early in our target
									--  second. If so, we don't want to wait around to
									--  (done_waiting + 1) to exit.

		next_sec = (1000 - ((dryos.ms_clock - tick_offset) % 1000))

		msleep (next_sec) -- Hard sleep, don't let anything else have priority.

	end

end


--
-- Say "CHEESE!".  Set up the camera, and take a picture.  Also deals with any requested
-- bracketing.
--
function take_shot(iso, shutter_speed, dobkt, bktstep, bktcount)
	
	if (ForceLiveView == 1)
	then
		beep(3,200)
		lv.start()			-- Boyang Liu 20190308
	end	
	
	local bktspeed = 0.0

	if ((lv.enabled == true) and (WarnLiveView == 1))
	then

		print ("TURN LIVEVIEW OFF (OR DISABLE MOVIE MODE) AND PRESS A BUTTON!!!")

		do_beep()

		key.wait()

	end

	camera.iso.value = iso

	if (dobkt == 0)
	then	-- Single exposure
		
		camera.shutter.value = shutter_speed

		log ("Click! Time: %s  ISO: %s  shutter: %s",
			pretty_time(get_cur_secs()), tostring(camera.iso.value), pretty_shutter(camera.shutter.value))

		if (DoShutterShockDelay == 1)
		then

			if ((shutter_speed >= FastestDelayedShutter) and (shutter_speed
				<= SlowestDelayedShutter))
			then
				
				msleep(ShutterShockDelayMS)			-- Boyang Liu 20190308
				--task.yield(ShutterShockDelayMS)

			end

		end

		if (TestBeepNoShutter == 0)
		then

			camera.shoot()
			task.yield(10) -- Exposures can take time.  Give other stuff a chance to run.

		else

			beep(1,50)
			task.yield (600 + camera.shutter.ms)

		end

	else	-- Bracketing exposure

		-- Loop through the requested number of exposure brackets.
		for bktnum = bktcount,(-1 * bktcount),-1 do

			bktspeed = shutter_speed * (2.0^(bktnum * bktstep))

			camera.shutter.value = bktspeed

			log ("Click! Time: %s  ISO: %s  shutter: %s",
				pretty_time(get_cur_secs()), tostring(camera.iso.value), pretty_shutter(camera.shutter.value))

			if (DoShutterShockDelay == 1)
			then

				if ((shutter_speed >= FastestDelayedShutter) and (shutter_speed
					<= SlowestDelayedShutter))
				then

					msleep(ShutterShockDelayMS)			-- Boyang Liu 20190308
					--task.yield(ShutterShockDelayMS)

				end

			end

			if (TestBeepNoShutter == 0) then

				camera.shoot()
				task.yield(10) -- Give other stuff a chance to run

			else

				beep(1,50)
				task.yield ((600 + camera.shutter.ms))

			end

		end
	end
end


--
-- Burst is simpler than single shot, because no brackets.  Set the camera, pull the trigger.
--
-- I have tried replacing this with multiple calls to "camera.shoot()", but it is still considerably
-- slower than "camera.burst()", and can also crash the camera -- nothing permanent, but still
-- not something I want to put out.
--
function take_burst (count, iso, speed)

	camera.shutter.value = speed
	camera.iso.value = iso

	if ((lv.enabled == true) and (WarnLiveView == 1))
	then

		print ("TURN LIVEVIEW OFF (OR DISABLE MOVIE MODE) AND PRESS A BUTTON!!!")

		do_beep()

		key.wait()

	end


	log ("Burst! Time: %s  ISO: %s  shutter: %s  count: %d",
		pretty_time(get_cur_secs()), tostring(camera.iso.value), pretty_shutter(camera.shutter.value), count)

	if (TestBeepNoShutter == 0)
	then

		camera.burst(count)

		task.yield(10)

	else

		beep(3,50)
		task.yield (4000 + (count * camera.shutter.ms))

	end

end


--
-- Take X pictures over Y seconds
--
-- The camera.burst() function is useful for taking exposures as fast as possible, but is
-- limited by the camera's buffer space.  Depending on the body, burst mode will fill the buffer in
-- around 2 seconds.  Even the slower cameras will fill the buffer with RAW images in 3-4 seconds,
-- which is too fast to reliably capture Baily's Beads.  Switching to JPG would help, but must be
-- done manually.  Not a good option for several reasons.
--
-- This function implements a manually controlled burst mode, which stretches out the exposure speed.
-- This spreads the time where the ~14 exposures that generally fit into the buffer out over a longer
-- time, and also gives the camera time to write to the card.  Instead of 14 frames over 4 seconds,
-- (~4fps) then slowing to maybe 4 frames every 3 seconds (1.5fps), we might be able to sustain
-- 2fps for 10 seconds.  Actual best framerate and duration will need testing for each camera and
-- memory card.
--
-- Timing is more important than number of exposures, so this function will exit at the end of the
-- specificed timespan, even if the required number of images have not been taken yet.
function take_timed_burst(count, timespan, iso, speed)

	local start_time = dryos.ms_clock -- Millisecond clock time that we're starting.
	local end_time = (dryos.ms_clock + (timespan * 1000)) -- Clock time (in milliseconds) where that we're done.
	local burst_interval = ((timespan * 1000) / count) -- Time between shutters, in milliseconds.
	local time_now = start_time
	local pause_time = 0
	local exposure_num = 0
	local last_time=0

	for exposure_num = 1, count, 1
	do

		last_time=time_now
		time_now = dryos.ms_clock

		take_shot (iso, speed, 0, 0, 0)

		if (time_now > end_time)
		then

			return -- No time for another image.

		else

			pause_time = ((start_time + burst_interval * exposure_num) - (dryos.ms_clock + 75))

			if (pause_time > 0) -- Pause for the next interval to pass, if we're not running late.
			then

				task.yield(pause_time)

			end

		end

	end

end


--
-- Simple annoying camera beep.
--
function do_beep()

		beep (5,100)

		task.yield (250)

		beep (5,100)

		task.yield (250)

		beep (5,100)

end
--
-- Take the spaced exposures for the C1-C2 and C3-C4 periods.  Take the margin times off either
-- end, split the time into the right intervals, and fire off take_picture()
--
function do_partial (start_phase, stop_phase, which_partial)

	local image_time = 0
	local image_interval = math.floor((stop_phase - start_phase) / (PartialExposureCount))
	local exposure_count = 0


	-- In a series of (PartialCount + 1) images, totality is either
	--	the first or last image.  This arranges the timing so that there
	--	will be a equidistance set of ((2 x PartialCount) + 1) exposures,
	--	with totality properly centered.

	if (which_partial == "Pre")
	then

		image_time = start_phase

	else

		image_time = start_phase + image_interval

	end

	if ( get_cur_secs() >= stop_phase ) -- Are we past this phase already?
	then

		log ("Skip %s Partial. Finished %d seconds ago.", which_partial, (get_cur_secs() - stop_phase))
		return

	end

	repeat

		log ("%s Partial: %d/%d  Interval: %d s  Remaining: %d",
			which_partial, exposure_count+1, PartialExposureCount, image_interval, stop_phase - get_cur_secs())
		if (get_cur_secs() <= image_time)
		then

			wait_until(image_time)

			take_shot (PartialISO, PartialShutterSpeed, PartialDoBkt, PartialBktStep, PartialBktCount)

		end

		image_time = image_time + image_interval

		exposure_count = exposure_count + 1

	until (exposure_count >= PartialExposureCount)

end


--
-- Start the burst shot a little before C2, then start running through exposure settings, going from
-- short, fast exposures to slow, long exposures and then back to short, until just before the midpoint
-- of the eclipse.  <strikethrough>Take two long exposures at that point, for good measure.</strikethrough>
--
function do_c2max()
	
	local cur_shutter_speed = 0
	local CurISO = 0

	if ( get_cur_secs() >= max_sec ) -- Are we past this phase already?
	then

		log ("Skip C2->Max. Finished %d seconds ago.", (get_cur_secs() - max_sec))
		return

	end

	if (get_cur_secs() <= (c2_sec - (math.max(RingStartOffset, C2BurstStartOffset) + 30)))
	then

		log ("Main C2->Max loop for %d seconds.", (c2_sec - (math.max(RingStartOffset, C2BurstStartOffset) + 30)))

		wait_until (c2_sec - (math.max(RingStartOffset, C2BurstStartOffset) + 30))

		print()
		print("********************************************************")
		log  ("30 seconds to C2!  Remove Filter!")
		print("********************************************************")
		print()

		do_beep()

	end


	if ((get_cur_secs() <= (c2_sec - RingStartOffset) ) and ( DoRing == 1)) -- Are we taking Diamond Ring shots?
	then

		wait_until (c2_sec - RingStartOffset)

		if (UseBurst == 1)
		then

			take_burst (RingBurstCount, RingBurstISO, RingBurstShutterSpeed)

		else

			take_timed_burst (RingBurstCount, RingBurstTime, RingBurstISO, RingBurstShutterSpeed)

		end

	end

	if ( get_cur_secs() < c2_sec ) -- Have we passed the burst for Baily's beads?
	then

		wait_until (c2_sec - C2BurstStartOffset)

		if (UseBurst == 1)
		then

			take_burst (C23BurstCount, C23BurstISO, C23BurstShutterSpeed)

		else

			take_timed_burst (C23BurstCount, C2BurstTime, C23BurstISO, C23BurstShutterSpeed)

		end

		print()
		print("********************************************************")
		log  ("Post C2 warning!")
		print("********************************************************")
		print()

		--do_beep()

	end

	cur_shutter_speed = TotalityMinShutterSpeed

	CurISO = TotalityMinISO

	repeat

		take_shot(CurISO, cur_shutter_speed, 0, 0, 0)

		if (CurISO < (TotalityPrefISO * 0.95))
		then

			CurISO = CurISO * 2.0^TotalityExpStep

		elseif ((CurISO < (TotalityPrefISO * 1.1)) and (cur_shutter_speed < (TotalityMaxShutterSpeed * 0.95)))
		then

			cur_shutter_speed = cur_shutter_speed * 2.0^TotalityExpStep

		elseif (CurISO < (TotalityMaxISO * 0.95))
		then

			CurISO = CurISO * 2.0^TotalityExpStep

		else

			cur_shutter_speed = TotalityMinShutterSpeed

			CurISO = TotalityMinISO

		end

	until (get_cur_secs() >= (max_sec - MaxOffset)) -- Stop, and leave time to do the mid-eclipse earthshine
													-- exposures.
end


--
-- do_max -- Take a number of long exposures at the time of maximum eclipse, to try to capture
-- an earthshine image.  These can be bracketed.
--
function do_max()

	if (DoMaxExposures == 0)  -- Are we doing this?
	then

		log ("Skip Max Eclipse long exposures. Not configured.")
		return 		-- Nope.

	end

	if ( get_cur_secs() >= max_sec) -- Have we passed max already?
	then

		log ("Skip Max. Finished %d seconds ago.", (get_cur_secs() - max_sec))
		return

	end
	for count_max_exp = NumMaxExposures , 1 , -1 do

		log ("do_max: MaxISO=%d, MaxShutterSpeed=%s, DoMaxBrackets=%d, NumMaxBrackets=%d, MaxBracketStep=%d",
			MaxISO, tostring(MaxShutterSpeed), DoMaxBrackets, NumMaxBrackets, MaxBracketStep)

		take_shot(MaxISO, MaxShutterSpeed, DoMaxBrackets, MaxBracketStep, NumMaxBrackets)

	end

end


--
-- Similar to do_c2max, but reversed.  Exposures run from longest to shortest (and then repeat),
-- the burst starts just before C3, and there are no bonus exposures.
--
function do_maxc3()

	local cur_shutter_speed = 0
	local CurISO = 0

	if ( get_cur_secs() >= (c3_sec + RingStartOffset) ) -- Are we past this phase already?
	then

		log ("Skip Max->C3. Finished %d seconds ago.", (get_cur_secs() - (c3_sec + C3BurstStartOffset)))
		return

	elseif ( get_cur_secs() < (c3_sec - C3BurstStartOffset) ) -- Do we have time for some totality exposures?
	then

		cur_shutter_speed = TotalityMaxShutterSpeed
		CurISO = TotalityMaxISO

		log ("Main Max->C3 loop for %d seconds.", (c3_sec - C3BurstStartOffset - get_cur_secs()))

		repeat

			take_shot(CurISO, cur_shutter_speed, 0, 0, 0)

			if (CurISO > (TotalityPrefISO * 1.05))
			then

				CurISO = CurISO / 2.0^TotalityExpStep

			elseif ((CurISO > (TotalityPrefISO * 0.95)) and (cur_shutter_speed > (TotalityMinShutterSpeed * 1.05)))
			then

				cur_shutter_speed = cur_shutter_speed / 2.0^TotalityExpStep

			elseif (CurISO > (TotalityMinISO * 1.01))
			then

				CurISO = CurISO / 2.0^TotalityExpStep

			else

				cur_shutter_speed = TotalityMaxShutterSpeed

				CurISO = TotalityMaxISO

			end

		until (get_cur_secs() >= (c3_sec - (C3BurstStartOffset + 3)))

		print()
		print("********************************************************")
		log  ("3 seconds to C3!  Filter warning!")
		print("********************************************************")
		print()

		--do_beep()

	end

	wait_until (c3_sec - C3BurstStartOffset)

	if (UseBurst == 1)
	then

		take_burst (C23BurstCount, C23BurstISO, C23BurstShutterSpeed)

	else

		take_timed_burst(C23BurstCount, C3BurstTime, C23BurstISO, C23BurstShutterSpeed)

	end

	if (DoRing == 1)
	then

		if (UseBurst == 1)
		then

			take_burst (RingBurstCount, RingBurstISO, RingBurstShutterSpeed)

		else

			take_timed_burst(RingBurstCount, RingBurstTime, RingBurstISO, RingBurstShutterSpeed)

		end

	end

	print()
	print("********************************************************")
	log  ("End of totality! Replace filter!")
	print("********************************************************")
	print()

	do_beep()

end


--
-- The ringleader.
--
function main()

	local starttime
	local offset = 0
	local offset_count = 0

	starttime = get_cur_secs()

	TestStartTime = starttime

    menu.close()
    console.show()
	log_start ()

	--
	-- The camera maintains a millisecond timer since power-on.  We can use this to
	-- get close to the beginning of a given second.  I think.
	--
	event.seconds_clock = function (ignore)

		offset = offset + (dryos.ms_clock - (1000 * offset_count))
		offset_count = offset_count + 1

	return true

end
	print ()
	print ()
	print ("-------------------------------------")
	print ("  Eclipse Magic")
	print ("  Copyright 2017, grnbrg@grnbrg.org")
	print ("  Released under the GNU GPL")
	print ("-------------------------------------")
	print ()
	print ("Starting 10 second timing calibration....")

	--
	-- There is a fair amount of jitter in the event timer.  Averaging over 10 seconds will
	-- give us a reasonable offset.
	--
	task.yield(10500)

	-- Turn off the second_clock event timer.
	event.seconds_clock = nil

	tick_offset = (math.floor(offset / offset_count) % 1000)

	print ("Done!")
	print ()
	log ("TestBeepNoShutter: %d", TestBeepNoShutter)
	log ("C1: %s", pretty_time(c1_sec))
	log ("C2: %s", pretty_time(c2_sec))
	log ("C3: %s", pretty_time(c3_sec))
	log ("C4: %s", pretty_time(c4_sec))

	-- If the camera is not in manual mode, trying to set the shutter speed throws errors.
	-- Check to make sure we are in manual mode, and refuse to run if we're not.
	if (camera.mode == MODE.M)
	then

		if (SetAperture == 1)
		then

			camera.aperture.value = Aperture1

		end

		do_partial ((c1_sec + PartialMarginTime), c2_sec, "Pre")
		
		if (SetAperture == 1)
		then

			camera.aperture.value = Aperture2

		end
		
		do_c2max()

		do_max()

		do_maxc3()
		
		if (SetAperture == 1)
		then

			camera.aperture.value = Aperture1

		end

		do_partial (c3_sec, (c4_sec - PartialMarginTime), "Post")

	else

		beep (5, 100)

		log  ("Camera must be in manual (M) mode!!")
		print()
		print("Press any button to exit the script.  Change the mode and re-run.")

		key.wait()

	end

	log ("All done. Normal exit.")
	log_stop ()
	print("Press any button to exit the script.")
	key.wait()
    console.hide()

end -- Done.  Hope there were no clouds.


main() -- Run the program.

-- CHANGES

-- 1.0.1
	-- Stopped running the seconds_clock event at all times, and moved the tick_offset
		-- calculation to the setup at the start of execution
	-- Fixed the pretty-printing of the timer
	-- Fixed the sign of the C23BurstStartOffset in do_maxc3
	-- Fixed the calculation of the difference between current time and the next second
		-- in wait_until()
	-- Added code to turn off the console during long waits
	-- Massaged the end-of-exposure-bracketing conditions in do_c2max() and do_maxc3()

-- 1.1
	-- Changed the partial phase exposure logic, so that instead of there being an exposure
		-- at C1 and C2, there is an exposure at C1 and an exposure at (C2 - exposure_interval)
		-- so that the totality images are properly centered between the requested partial phase
		-- exposures.
	-- Added an alarm at 30 seconds before C2 and 3 seconds before C3 to alert for any filter changes.
		-- There is also a beep after the C2 and C3 bursts to flag any needed changes.
	-- Split the C23BurstStartOffset into separate variables, to allow an asymmetric burst over
		-- each period.  (ie: 10 seconds before C2 to 3 seconds after C2)

-- 1.2
	-- Added ISO brackets to totality exposure sequence.  Totality now has a preferred ISO,
		-- and will shift to that ISO at the fastest or slowest shutter speeds, then use that
		-- preferred ISO for the requested range of shutter speeds, then shift ISO to the end of
		-- the requested range.
	-- Option to stop LiveView before touching the shutter controls.
	-- Removed the two long exposures at max eclipse -- probably not needed.

-- 1.2.1
	-- Changed call to lv.stop() to a beep, and instruction to the user to turn off LV.
		-- lv.stop() doesn't seem to work.
	-- Added print statements to explain filter warning beeps.

-- 1.3.0
	-- Changed the startup timing loop to be more accurate if the script is started close to
	    -- a second boundary.  (The average offset of 999ms and 1ms is 1ms, not 500ms)
	-- Corrected an error in wait_until() -- Used div, where modulus was correct, and had
	    -- the tick_offset correction wrong.  Don't code while tired.  Thanks to
		-- matman730 for pointing out this goof.
	-- Improved the configuration comments around TestBeepNoShutter.  They apparently weren't
	    -- clear as I thought.

-- 1.4.0  (Not released)
		-- Attempt to implment the changing of the file prefix for the saved images.  It didn't
			-- work well, and I scrapped it.

-- 1.5.0
	-- Make it optional to hide the console during script running, and allow the delay before
		-- and after the next image to be configured.
	-- Shutter shock reduction:  Add a configurable (in milliseconds) delay before an exposure
		-- where the shutter speed is within a (also configurable) range.
	-- Add a mid-eclipse section.  This is a short section around the max eclipse point to optionally
		-- try for some earthshine exposures.
	-- Set the aperture on program start.

-- 1.6.0 -- Contributions from Eric Krohn, <krohn@ekrohn.com> (Many thanks!)
	-- Added logging to permanent file, "ECLIPSE.LOG" at top level of the memory card
	-- More extensive logging added throughout the script
	-- Bugfix:  In do_max() the last two arguments to take_shot() were reversed.
	-- Bugfix:  do_max() is unguarded as far as current time
	-- Added pretty_shutter() to make the shutter speed numbers more sensible

-- 1.7.0
	-- Added optional function to take some diamond ring images before and after the Baily's Beads
		-- exposures.  Be careful not to overlap the Ring and Beads exposures before C2!
	-- Added a new burst function that takes a burst of images, one at a time, rather than using the
		-- camera's burst function.  Slower, but slower is better for the buffer, and gives us the
		-- opportunity to stop shooting at a specific time, where a burst will run until the requested
		-- number of images have been captured.

-- 1.7.1 by Boyang Liu
	-- Fixed partial exposure count number (now starting from 1, not from 0)
	-- Changed the filename, so it won't be too long to load (magiclantern-lua_fix.2018Dec23.6D116 does not allow long filename)
	-- Fixed the "TestBeepNoShutter == 1" into "TestBeepNoShutter == 0". Now testing is really testing, no confuse.
	-- Added warning information in script comment: "Only interger numbers are accepted!"
	-- Added ForceLiveView parameter to ensure the mirror is up.
	-- Added beep before lv.start()