pi-timolo.py

#!/usr/bin/env python3

"""
pi-timolo - Raspberry Pi Long Duration Timelapse, Motion Tracking,
with Low Light Capability
written by Claude Pageau Jul-2017 (release 7.x)
This release uses OpenCV to do Motion Tracking.
It requires updated config.py
Oct 2020 Added panoramic pantilt option plus other improvements.
"""

import os

WARN_ON = False  # Add short delay to review warning messages
MY_PATH = os.path.abspath(__file__)  # Find the full path of this python script
# get the path location only (excluding script name)
BASE_DIR = os.path.dirname(MY_PATH)
BASE_FILENAME = os.path.splitext(os.path.basename(MY_PATH))[0]
PROG_NAME = os.path.basename(__file__)
LOG_FILE_PATH = os.path.join(BASE_DIR, BASE_FILENAME + ".log")
HORIZ_LINE = "-------------------------------------------------------"
print(HORIZ_LINE)
print(f"{PROG_NAME} written by Claude Pageau")
print(HORIZ_LINE)
print("Loading Wait ....")

# import python library modules
import datetime
import logging
import sys
import subprocess
import shutil
import glob
import time
import math
from threading import Thread
from fractions import Fraction

from dateutil.parser import parse
import numpy as np
from PIL import Image
from PIL import ImageFont
from PIL import ImageDraw
import pyexiv2


"""
This is a dictionary of the default settings for pi-timolo.py
If you don't want to use a config.py file these will create the required
variables with default values.  Change dictionary values if you want different
variable default values.
A message will be displayed if a variable is Not imported from config.py.
Note: plugins can override default and config.py values if plugins are
      enabled.  This happens after config.py variables are initialized
"""

default_settings = {
    "CONFIG_FILENAME": "default_settings",
    "CONFIG_TITLE": "No config.py so using internal dictionary settings",
    "PLUGIN_ON": False,
    "PLUGIN_NAME": "shopcam",
    "VERBOSE_ON": True,
    "LOG_TO_FILE_ON": False,
    "DEBUG_ON": False,
    "IMAGE_NAME_PREFIX": "cam1-",
    "IMAGE_WIDTH": 1920,
    "IMAGE_HEIGHT": 1080,
    "IMAGE_FORMAT": ".jpg",
    "IMAGE_JPG_QUAL": 95,
    "IMAGE_ROTATION": 0,
    "IMAGE_VFLIP": True,
    "IMAGE_HFLIP": True,
    "IMAGE_GRAYSCALE": False,
    "IMAGE_PREVIEW": False,
    "IMAGE_PIX_AVE_TIMER_SEC": 15,
    "IMAGE_NO_NIGHT_SHOTS": False,
    "IMAGE_NO_DAY_SHOTS": False,
    "IMAGE_SHOW_STREAM": False,
    "STREAM_WIDTH": 320,
    "STREAM_HEIGHT": 240,
    "STREAM_FPS": 20,
    "STREAM_STOP_SEC": 0.7,
    "SHOW_DATE_ON_IMAGE": True,
    "SHOW_TEXT_FONT_SIZE": 18,
    "SHOW_TEXT_BOTTOM": True,
    "SHOW_TEXT_WHITE": True,
    "SHOW_TEXT_WHITE_NIGHT": True,
    "NIGHT_TWILIGHT_MODE_ON": True,
    "NIGHT_TWILIGHT_THRESHOLD": 90,
    "NIGHT_DARK_THRESHOLD": 50,
    "NIGHT_BLACK_THRESHOLD": 4,
    "NIGHT_SLEEP_SEC": 30,
    "NIGHT_MAX_SHUT_SEC": 5.9,
    "NIGHT_MAX_ISO": 800,
    "NIGHT_DARK_ADJUST": 4.7,
    "TIMELAPSE_ON": True,
    "TIMELAPSE_DIR": "media/timelapse",
    "TIMELAPSE_PREFIX": "tl-",
    "TIMELAPSE_START_AT": "",
    "TIMELAPSE_TIMER_SEC": 300,
    "TIMELAPSE_CAM_SLEEP_SEC": 4.0,
    "TIMELAPSE_NUM_ON": True,
    "TIMELAPSE_NUM_RECYCLE_ON": True,
    "TIMELAPSE_NUM_START": 1000,
    "TIMELAPSE_NUM_MAX": 2000,
    "TIMELAPSE_EXIT_SEC": 0,
    "TIMELAPSE_MAX_FILES": 0,
    "TIMELAPSE_SUBDIR_MAX_FILES": 0,
    "TIMELAPSE_SUBDIR_MAX_HOURS": 0,
    "TIMELAPSE_RECENT_MAX": 40,
    "TIMELAPSE_RECENT_DIR": "media/recent/timelapse",
    "MOTION_TRACK_ON": True,
    "MOTION_TRACK_QUICK_PIC_ON": False,
    "MOTION_TRACK_INFO_ON": True,
    "MOTION_TRACK_TIMEOUT_SEC": 0.3,
    "MOTION_TRACK_TRIG_LEN": 75,
    "MOTION_TRACK_MIN_AREA": 100,
    "MOTION_TRACK_QUICK_PIC_BIGGER": 3.0,
    "MOTION_DIR": "media/motion",
    "MOTION_PREFIX": "mo-",
    "MOTION_START_AT": "",
    "MOTION_VIDEO_ON": False,
    "MOTION_VIDEO_FPS": 15,
    "MOTION_VIDEO_WIDTH": 640,
    "MOTION_VIDEO_HEIGHT": 480,
    "MOTION_VIDEO_TIMER_SEC": 10,
    "MOTION_TRACK_MINI_TL_ON": False,
    "MOTION_TRACK_MINI_TL_SEQ_SEC": 20,
    "MOTION_TRACK_MINI_TL_TIMER_SEC": 4,
    "MOTION_TRACK_PANTILT_SEQ_ON": False,
    "MOTION_FORCE_SEC": 3600,
    "MOTION_NUM_ON": True,
    "MOTION_NUM_RECYCLE_ON": True,
    "MOTION_NUM_START": 1000,
    "MOTION_NUM_MAX": 500,
    "MOTION_SUBDIR_MAX_FILES": 0,
    "MOTION_SUBDIR_MAX_HOURS": 0,
    "MOTION_RECENT_MAX": 40,
    "MOTION_RECENT_DIR": "media/recent/motion",
    "MOTION_DOTS_ON": False,
    "MOTION_DOTS_MAX": 100,
    "MOTION_CAM_SLEEP": 0.7,
    "CREATE_LOCKFILE": False,
    "VIDEO_REPEAT_ON": False,
    "VIDEO_REPEAT_WIDTH": 1280,
    "VIDEO_REPEAT_HEIGHT": 720,
    "VIDEO_DIR": "media/videos",
    "VIDEO_PREFIX": "vid-",
    "VIDEO_START_AT": "",
    "VIDEO_FILE_SEC": 120,
    "VIDEO_SESSION_MIN": 60,
    "VIDEO_FPS": 30,
    "VIDEO_NUM_ON": False,
    "VIDEO_NUM_RECYCLE_ON": False,
    "VIDEO_NUM_START": 100,
    "VIDEO_NUM_MAX": 20,
    "PANTILT_ON": False,
    "PANTILT_IS_PIMORONI": False,
    "PANTILT_HOME": (0, -10),
    "PANTILT_SPEED": 0.5,
    "PANTILT_SEQ_ON": False,
    "PANTILT_SEQ_TIMER_SEC": 600,
    "PANTILT_SEQ_IMAGES_DIR": "media/pantilt_seq",
    "PANTILT_SEQ_IMAGE_PREFIX": "seq-",
    "PANTILT_SEQ_DAYONLY_ON": True,
    "PANTILT_SEQ_RECENT_DIR": "media/recent/pt-seq",
    "PANTILT_SEQ_NUM_MAX": 200,
    "PANTILT_SEQ_NUM_ON": True,
    "PANTILT_SEQ_NUM_START": 1000,
    "PANTILT_SEQ_NUM_RECYCLE_ON": True,
    "PANTILT_SEQ_NUM_MAX": 200,
    "PANTILT_SEQ_STOPS": [
        (90, 10),
        (45, 10),
        (0, 10),
        (-45, 10),
        (-90, 10),
    ],
    "PANO_ON": False,
    "PANO_DAYONLY_ON": True,
    "PANO_TIMER_SEC": 160,
    "PANO_IMAGE_PREFIX": "pano-",
    "PANO_NUM_START": 1000,
    "PANO_NUM_MAX": 10,
    "PANO_NUM_RECYCLE": True,
    "PANO_PROG_PATH": "./image-stitching",
    "PANO_IMAGES_DIR": "./media/pano/images",
    "PANO_DIR": "./media/pano/panos",
    "PANO_CAM_STOPS": [
        (36, 10),
        (0, 10),
        (-36, 10),
    ],
    "SPACE_TIMER_HOURS": 0,
    "SPACE_TARGET_MB": 500,
    "SPACE_MEDIA_DIR": "/home/pi/pi-timolo/media",
    "SPACE_TARGET_EXT": "jpg",
    "web_server_port": 8080,
    "web_server_root": "media",
    "web_page_title": "PI-TIMOLO Media",
    "web_page_refresh_on": True,
    "web_page_refresh_sec": "900",
    "web_page_blank": False,
    "web_image_height": "768",
    "web_iframe_width_usage": "70%",
    "web_iframe_width": "100%",
    "web_iframe_height": "100%",
    "web_max_list_entries": 0,
    "web_list_height": "768",
    "web_list_by_datetime": True,
    "web_list_sort_descending": True,
}

# Check for config.py variable file to import and error out if not found.
CONFIG_FILE_PATH = os.path.join(BASE_DIR, "config.py")
if os.path.isfile(CONFIG_FILE_PATH):
    try:
        # Read Configuration variables from config.py file
        from config import *
    except ImportError:
        print("WARN  : Problem Importing Variables from %s" % CONFIG_FILE_PATH)
        WARN_ON = True
else:
    print(
        "WARN  : %s File Not Found. Cannot Import Configuration Variables."
        % CONFIG_FILE_PATH
    )
    WARN_ON = True
"""
Check if variables were imported from config.py. If not create variable using
the values in the default_settings dictionary above.
"""
for key, val in default_settings.items():
    try:
        exec(key)
    except NameError:
        print("WARN  : config.py Variable Not Found. Setting " + key + " = " + str(val))
        exec(key + "=val")
        WARN_ON = True

## TODO: Refactor Pantilt support so it doesn't download files and uses public
##  distribution of libraries.
if PANTILT_ON:
    pan_x, tilt_y = PANTILT_HOME
    if PANTILT_IS_PIMORONI:
        try:
            import pantilthat
        except ImportError:
            print("ERROR : Import Pimoroni PanTiltHat Python Library per")
            print("        sudo apt install pantilthat")
            print("        Enable I2C support using sudo raspi-config")
            sys.exit()
        try:
            pantilthat.pan(pan_x)
        except IOError:
            print("ERROR: pimoroni pantilthat hardware problem")
            print(
                "       if pimoroni pantilt installed check that I2C enabled in raspi-config."
            )
            print("if waveshare or conpatible pantilt installed perform the following")
            print("nano edit config.py per below")
            print("    nano config.py")
            print("Change value of variable per below. ctrl-x y to save and exit")
            print("    PANTILT_IS_PIMORONI = False")
            sys.exit()
        pantilt_is = "Pimoroni"
    else:
        try:
            # import pantilthat
            from waveshare.pantilthat import PanTilt
        except ImportError:
            print("ERROR : Install Waveshare PanTiltHat Python Library per")
            print(
                "        curl -L https://raw.githubusercontent.com/pageauc/waveshare.pantilthat/main/install.sh | bash"
            )
            sys.exit()
        try:
            pantilthat = PanTilt()
            pantilthat.pan(pan_x)
        except IOError:
            print("ERROR: pantilthat hardware problem")
            print("nano edit config.py per below")
            print("    nano config.py")
            print("Change value of variable per below. ctrl-x y to save and exit")
            print("    PANTILT_IS_PIMORONI = True")
            sys.exit()
        pantilt_is = "Waveshare"
# Setup Logging now that variables are imported from config.py/plugin
if LOG_TO_FILE_ON:
    logging.basicConfig(
        level=logging.DEBUG,
        format="%(asctime)s %(levelname)-8s %(funcName)-10s %(message)s",
        datefmt="%Y-%m-%d %H:%M:%S",
        filename=LOG_FILE_PATH,
        filemode="w",
    )
elif VERBOSE_ON:
    logging.basicConfig(
        level=logging.DEBUG,
        format="%(asctime)s %(levelname)-8s %(funcName)-10s %(message)s",
        datefmt="%Y-%m-%d %H:%M:%S",
    )
else:
    logging.basicConfig(
        level=logging.CRITICAL,
        format="%(asctime)s %(levelname)-8s %(funcName)-10s %(message)s",
        datefmt="%Y-%m-%d %H:%M:%S",
    )
# Check for user_motion_code.py file to import and error out if not found.
userMotionFilePath = os.path.join(BASE_DIR, "user_motion_code.py")
if not os.path.isfile(userMotionFilePath):
    print(
        "WARN  : %s File Not Found. Cannot Import user_motion_code functions."
        % userMotionFilePath
    )
    WARN_ON = True
else:
    # Read Configuration variables from config.py file
    try:
        motionCode = True
        import user_motion_code
    except ImportError:
        print("WARN  : Failed Import of File user_motion_code.py Investigate Problem")
        motionCode = False
        WARN_ON = True
# Give some time to read any warnings
if WARN_ON and VERBOSE_ON:
    print("")
    print("Please Review Warnings  Wait 10 sec ...")
    time.sleep(10)
    print("Loading Wait ....")
try:
    import cv2
except ImportError:
    if sys.version_info > (2, 9):
        logging.error("Failed to import cv2 opencv for python3")
        logging.error("Try installing opencv for python3")
        logging.error("See https://github.com/pageauc/opencv3-setup")
    else:
        logging.error("Failed to import cv2 for python2")
        logging.error("Try reinstalling per command")
        logging.error("sudo apt-get install python-opencv")
    logging.error("Exiting %s Due to Error", PROG_NAME)
    sys.exit(1)
try:
    from picamera import PiCamera
except ImportError:
    logging.error("Problem importing picamera module")
    logging.error("Try command below to import module")
    if sys.version_info > (2, 9):
        logging.error("sudo apt-get install python3-picamera")
    else:
        logging.error("sudo apt-get install python-picamera")
    logging.error("Exiting %s Due to Error", PROG_NAME)
    sys.exit(1)
from picamera.array import PiRGBArray
import picamera.array

# Check that pi camera module is installed and enabled
logging.info("Checking Pi Camera Module using command - vcgencmd get_camera")
camResult = subprocess.check_output("vcgencmd get_camera", shell=True)
camResult = camResult.decode("utf-8")
camResult = camResult.replace("\n", "")
params = camResult.split()
for x in range(0, 2):
    if params[x].find("0") >= 0:
        logging.error("Detected picamera issue per %s", params[x])
        logging.error("  if supported=0 Enable Camera per command  sudo raspi-config")
        logging.error("  Bullseye and later enable Legacy picamera support.")
        logging.error(
            "  if detected=0 Check Pi Camera Module and cable is Installed Correctly."
        )
        logging.error("Pi-Timolo Exiting Due to Error")
        sys.exit(1)
else:
    logging.info("Success Pi Camera %s", camResult)
    # use raspistill to check maximum image resolution of attached camera module
    logging.info("Checking Pi Camera Module Version Wait ...")
    import picamera

    with picamera.PiCamera() as camera:
        CAM_MAX_RESOLUTION = camera.MAX_RESOLUTION
    logging.info("PiCamera Max resolution is %s", CAM_MAX_RESOLUTION)
    CAM_MAX_WIDTH, CAM_MAX_HEIGHT = CAM_MAX_RESOLUTION.width, CAM_MAX_RESOLUTION.height
    if CAM_MAX_WIDTH == "3280":
        picameraVer = "2"
    else:
        picameraVer = "1"
    logging.info("PiCamera Module Hardware is Ver %s", picameraVer)


if PLUGIN_ON:  # Check and verify plugin and load variable overlay
    pluginDir = os.path.join(BASE_DIR, "plugins")
    # Check if there is a .py at the end of PLUGIN_NAME variable
    if PLUGIN_NAME.endswith(".py"):
        PLUGIN_NAME = PLUGIN_NAME[:-3]  # Remove .py extensiion
    pluginPath = os.path.join(pluginDir, PLUGIN_NAME + ".py")
    logging.info("pluginEnabled - loading PLUGIN_NAME %s", pluginPath)
    if not os.path.isdir(pluginDir):
        logging.error("plugin Directory Not Found at %s", pluginDir)
        logging.error("Rerun ./install-pi-timolo.sh to create plugin Directory")
        logging.error("Exiting %s Due to Error", PROG_NAME)
        sys.exit(1)
    elif not os.path.isfile(pluginPath):
        logging.error("File Not Found PLUGIN_NAME %s", pluginPath)
        logging.error("Check Spelling of PLUGIN_NAME Value in %s", CONFIG_FILE_PATH)
        logging.error("------- Valid Names -------")
        validPlugin = glob.glob(pluginDir + "/*py")
        validPlugin.sort()
        for entry in validPlugin:
            pluginFile = os.path.basename(entry)
            plugin = pluginFile.rsplit(".", 1)[0]
            if not ((plugin == "__init__") or (plugin == "current")):
                logging.error("        %s", plugin)
        logging.error("------- End of List -------")
        logging.error("Note: PLUGIN_NAME Should Not have .py Ending.")
        logging.error("Rerun ./install-pi-timolo.sh to create plugin Directory")
        logging.error("Exiting %s Due to Error", PROG_NAME)
        sys.exit(1)
    else:
        pluginCurrent = os.path.join(pluginDir, "current.py")
        try:  # Copy image file to recent folder
            # TODO: Why are we copying files?
            logging.info("Copy %s to %s", pluginPath, pluginCurrent)
            shutil.copy(pluginPath, pluginCurrent)
        except OSError as err:
            logging.error(
                "Copy Failed from %s to %s - %s", pluginPath, pluginCurrent, err
            )
            logging.error("Check permissions, disk space, Etc.")
            logging.error("Exiting %s Due to Error", PROG_NAME)
            sys.exit(1)
        logging.info("Import Plugin %s", pluginPath)
        sys.path.insert(0, pluginDir)  # add plugin directory to program PATH
        from plugins.current import *

        try:
            if os.path.isfile(pluginCurrent):
                os.remove(pluginCurrent)
            pluginCurrentpyc = os.path.join(pluginDir, "current.pyc")
            if os.path.isfile(pluginCurrentpyc):
                os.remove(pluginCurrentpyc)
        except OSError as err:
            logging.warning("Failed Removal of %s - %s", pluginCurrentpyc, err)
            time.sleep(5)
else:
    logging.info("No Plugin Enabled per PLUGIN_ON=%s", PLUGIN_ON)
# Turn on VERBOSE_ON when DEBUG_ON mode is enabled
if DEBUG_ON:
    VERBOSE_ON = True
# Make sure image format extention starts with a dot
if not IMAGE_FORMAT.startswith(".", 0, 1):
    IMAGE_FORMAT = "." + IMAGE_FORMAT
# ==================================
#      System Variables
# Should Not need to be customized
# ==================================
SECONDS2MICRO = 1000000  # Used to convert from seconds to microseconds
NIGHT_MAX_SHUTTER = int(NIGHT_MAX_SHUT_SEC * SECONDS2MICRO)
# default=5 seconds IMPORTANT- 6 seconds works sometimes
# but occasionally locks RPI and HARD reboot required to clear
darkAdjust = int((SECONDS2MICRO / 5.0) * NIGHT_DARK_ADJUST)
daymode = False  # default should always be False.
MOTION_PATH = os.path.join(BASE_DIR, MOTION_DIR)  # Store Motion images
# motion dat file to save currentCount

# Setup filepath's for storing image numbering data
DATA_DIR = "./data"
NUM_PATH_MOTION = os.path.join(DATA_DIR, MOTION_PREFIX + BASE_FILENAME + ".dat")
NUM_PATH_TIMELAPSE = os.path.join(DATA_DIR, TIMELAPSE_PREFIX + BASE_FILENAME + ".dat")
NUM_PATH_PANO = os.path.join(DATA_DIR, PANO_IMAGE_PREFIX + BASE_FILENAME + ".dat")
NUM_PATH_PANTILT_SEQ = os.path.join(
    DATA_DIR, PANTILT_SEQ_IMAGE_PREFIX + BASE_FILENAME + ".dat"
)

TIMELAPSE_PATH = os.path.join(BASE_DIR, TIMELAPSE_DIR)  # Store Time Lapse images
# timelapse dat file to save currentCount
LOCK_FILEPATH = os.path.join(BASE_DIR, BASE_FILENAME + ".sync")
# Colors for drawing lines
cvWhite = (255, 255, 255)
cvBlack = (0, 0, 0)
cvBlue = (255, 0, 0)
cvGreen = (0, 255, 0)
cvRed = (0, 0, 255)
LINE_THICKNESS = 1  # Thickness of opencv drawing lines
LINE_COLOR = cvWhite  # color of lines to highlight motion stream area

# Round image resolution to avoid picamera errors
if picameraVer == "2":
    imageWidthMax = 3280
    imageHeightMax = 2464
else:
    imageWidthMax = 2592
    imageHeightMax = 1944
logging.info(
    "picamera ver %s Max Resolution is %i x %i",
    picameraVer,
    imageWidthMax,
    imageHeightMax,
)

# Round image resolution to avoid picamera errors
image_width = (IMAGE_WIDTH + 31) // 32 * 32
if image_width > imageWidthMax:
    image_width = imageWidthMax
image_height = (IMAGE_HEIGHT + 15) // 16 * 16

if image_height > imageHeightMax:
    image_height = imageHeightMax
stream_width = (STREAM_WIDTH + 31) // 32 * 32
if stream_width > imageWidthMax:
    stream_width = imageWidthMax
stream_height = (STREAM_HEIGHT + 15) // 16 * 16
if stream_height > imageHeightMax:
    stream_height = imageHeightMax
stream_framerate = STREAM_FPS  # camera framerate

# If camera being used inside where there is no twilight
# Reduce night threshold settings to reduce overexposures.
if not NIGHT_TWILIGHT_MODE_ON:
    NIGHT_TWILIGHT_THRESHOLD = 20
    NIGHT_DARK_THRESHOLD = 10
    NIGHT_BLACK_THRESHOLD = 4
# increase size of MOTION_TRACK_QUICK_PIC_ON image
bigImage = MOTION_TRACK_QUICK_PIC_BIGGER
bigImageWidth = int(stream_width * bigImage)
bigImageHeight = int(stream_height * bigImage)
TRACK_TRIG_LEN = MOTION_TRACK_TRIG_LEN  # Pixels moved to trigger motion photo
# Don't track progress until this Len reached.
TRACK_TRIG_LEN_MIN = int(MOTION_TRACK_TRIG_LEN / 6)
# Set max overshoot triglen allowed half cam height
TRACK_TRIG_LEN_MAX = int(stream_height / 2)
# Timeout seconds Stops motion tracking when no activity
TRACK_TIMEOUT = MOTION_TRACK_TIMEOUT_SEC
# OpenCV Contour sq px area must be greater than this.
MIN_AREA = MOTION_TRACK_MIN_AREA
BLUR_SIZE = 10  # OpenCV setting for Gaussian difference image blur
THRESHOLD_SENSITIVITY = 20  # OpenCV setting for difference image threshold

# Fix range Errors  Use zero to set default quality to 85
if IMAGE_JPG_QUAL < 1:
    IMAGE_JPG_QUAL = 85
elif IMAGE_JPG_QUAL > 100:
    IMAGE_JPG_QUAL = 100


# ------------------------------------------------------------------------------
class PiVideoStream:
    """
    Create a picamera in memory video stream and
    return a frame when update called
    """

    def __init__(
        self,
        resolution=(stream_width, stream_height),
        framerate=stream_framerate,
        rotation=0,
        hflip=False,
        vflip=False,
    ):
        # initialize the camera and stream
        try:
            self.camera = PiCamera()
        except:
            logging.error("PiCamera Already in Use by Another Process")
            logging.error("Exiting %s Due to Error", PROG_NAME)
            exit(1)
        self.camera.resolution = resolution
        self.camera.framerate = framerate
        self.camera.hflip = hflip
        self.camera.vflip = vflip
        self.camera.rotation = rotation
        self.rawCapture = PiRGBArray(self.camera, size=resolution)
        self.stream = self.camera.capture_continuous(
            self.rawCapture, format="bgr", use_video_port=True
        )
        # initialize the frame and the variable used to indicate
        # if the thread should be stopped
        self.thread = None  # Initialize thread
        self.frame = None
        self.stopped = False

    def start(self):
        """start the thread to read frames from the video stream"""
        self.thread = Thread(target=self.update, args=())
        self.thread.daemon = True
        self.thread.start()
        return self

    def update(self):
        """keep looping infinitely until the thread is stopped"""
        for f in self.stream:
            # grab the frame from the stream and clear the stream in
            # preparation for the next frame
            self.frame = f.array
            self.rawCapture.truncate(0)
            # if the thread indicator variable is set, stop the thread
            # and release camera resources
            if self.stopped:
                self.stream.close()
                self.rawCapture.close()
                self.camera.close()
                return

    def read(self):
        """return the frame most recently read"""
        return self.frame

    def stop(self):
        """indicate that the thread should be stopped"""
        self.stopped = True
        if self.thread is not None:
            self.thread.join()


# ------------------------------------------------------------------------------
def shut2sec(shutspeed):
    """Convert camera shutter speed setting to string"""
    shutspeedSec = shutspeed / float(SECONDS2MICRO)
    shutstring = str("%.4f") % (shutspeedSec)
    return shutstring


# ------------------------------------------------------------------------------
def showTime():
    """Show current date time in text format"""
    rightNow = datetime.datetime.now()
    currentTime = "%04d-%02d-%02d %02d:%02d:%02d" % (
        rightNow.year,
        rightNow.month,
        rightNow.day,
        rightNow.hour,
        rightNow.minute,
        rightNow.second,
    )
    return currentTime


# ------------------------------------------------------------------------------
def showDots(dotcnt):
    """
    If motionShowDots=True then display a progress
    dot for each cycle.  If MOTION_TRACK_ON then this would
    normally be too fast and should be turned off
    """
    if MOTION_DOTS_ON:
        if MOTION_TRACK_ON and VERBOSE_ON:
            dotcnt += 1
            if dotcnt > MOTION_DOTS_MAX + 2:
                print("")
                dotcnt = 0
            elif dotcnt > MOTION_DOTS_MAX:
                print("")
                stime = showTime() + " ."
                sys.stdout.write(stime)
                sys.stdout.flush()
                dotcnt = 0
            else:
                sys.stdout.write(".")
                sys.stdout.flush()
    return dotcnt


# ------------------------------------------------------------------------------
def checkConfig():
    """
    Check if both User disabled everything
    in config.py. At least one option needs to be enabled
    """
    if (
        not MOTION_TRACK_ON
        and not TIMELAPSE_ON
        and not PANTILT_SEQ_ON
        and not PANO_ON
        and not VIDEO_REPEAT_ON
    ):
        errorText = (
            "You need to have Motion, Timelapse, PanTilt Seq, Pano or Video Repeat turned ON\n"
            "MOTION_TRACK_ON=%s TIMELAPSE_ON=%s PANTILT_SEQ_ON=%s PANO_ON=%s VIDEO_REPEAT_ON=%s"
            % (MOTION_TRACK_ON, TIMELAPSE_ON, PANTILT_SEQ_ON, PANO_ON, VIDEO_REPEAT_ON)
        )
        if VERBOSE_ON:
            logging.error(errorText)
        else:
            sys.stdout.write(errorText)
        sys.exit(1)


# ------------------------------------------------------------------------------
def displayInfo(motioncount, timelapsecount):
    """Display variable settings with plugin overlays if required"""
    if VERBOSE_ON:
        print(
            "----------------------------------- Settings "
            "-----------------------------------"
        )
        print(
            "Config File .. CONFIG_FILENAME=%s  CONFIG_TITLE=%s"
            % (CONFIG_FILENAME, CONFIG_TITLE)
        )
        if PLUGIN_ON:
            print(
                "     Plugin .. PLUGIN_ON=%s  PLUGIN_NAME=%s"
                " (Overlays %s Variable Settings)"
                % (PLUGIN_ON, PLUGIN_NAME, CONFIG_FILENAME)
            )
        else:
            print("     Plugin .. PLUGIN_ON=%s" % PLUGIN_ON)
        print("")
        print(
            "Image Info ... Size=%ix%i  ext=%s  Prefix=%s"
            "  VFlip=%s  HFlip=%s  Rotation=%i"
            % (
                image_width,
                image_height,
                IMAGE_FORMAT,
                IMAGE_NAME_PREFIX,
                IMAGE_VFLIP,
                IMAGE_HFLIP,
                IMAGE_ROTATION,
            )
        )
        print(
            "               IMAGE_GRAYSCALE=%s   Preview=%s"
            % (IMAGE_GRAYSCALE, IMAGE_PREVIEW)
        )
        if IMAGE_FORMAT == ".jpg" or IMAGE_FORMAT == ".jpeg":
            print(
                "               JpegQuality=%i where 1=Low 100=High" % (IMAGE_JPG_QUAL)
            )
        print(
            "   Low Light.. NIGHT_TWILIGHT_MODE_ON=%s  NIGHT_TWILIGHT_THRESHOLD=%i"
            "  NIGHT_DARK_THRESHOLD=%i  NIGHT_BLACK_THRESHOLD=%i"
            % (
                NIGHT_TWILIGHT_MODE_ON,
                NIGHT_TWILIGHT_THRESHOLD,
                NIGHT_DARK_THRESHOLD,
                NIGHT_BLACK_THRESHOLD,
            )
        )
        print(
            "               NIGHT_MAX_SHUT_SEC=%.2f  NIGHT_MAX_ISO=%i"
            "  NIGHT_DARK_ADJUST=%.2f  NIGHT_SLEEP_SEC=%i"
            % (NIGHT_MAX_SHUT_SEC, NIGHT_MAX_ISO, NIGHT_DARK_ADJUST, NIGHT_SLEEP_SEC)
        )
        print(
            "   No Shots .. IMAGE_NO_NIGHT_SHOTS=%s   IMAGE_NO_DAY_SHOTS=%s"
            % (IMAGE_NO_NIGHT_SHOTS, IMAGE_NO_DAY_SHOTS)
        )

        if SHOW_DATE_ON_IMAGE:
            print(
                "   Img Text .. On=%s  Bottom=%s (False=Top)  WhiteText=%s (False=Black)"
                % (SHOW_DATE_ON_IMAGE, SHOW_TEXT_BOTTOM, SHOW_TEXT_WHITE)
            )
            print(
                "               SHOW_TEXT_WHITE_NIGHT=%s  SHOW_TEXT_FONT_SIZE=%i px height"
                % (SHOW_TEXT_WHITE_NIGHT, SHOW_TEXT_FONT_SIZE)
            )
        else:
            print(
                "    No Text .. SHOW_DATE_ON_IMAGE=%s  Text on Image is Disabled"
                % (SHOW_DATE_ON_IMAGE)
            )
        print("")
        if MOTION_TRACK_ON:
            print(
                "Motion Track.. On=%s  Prefix=%s  MinArea=%i sqpx"
                "  TrigLen=%i-%i px  TimeOut=%i sec"
                % (
                    MOTION_TRACK_ON,
                    MOTION_PREFIX,
                    MOTION_TRACK_MIN_AREA,
                    MOTION_TRACK_TRIG_LEN,
                    TRACK_TRIG_LEN_MAX,
                    MOTION_TRACK_TIMEOUT_SEC,
                )
            )
            print(
                "               MOTION_TRACK_INFO_ON=%s   MOTION_DOTS_ON=%s  IMAGE_SHOW_STREAM=%s"
                % (MOTION_TRACK_INFO_ON, MOTION_DOTS_ON, IMAGE_SHOW_STREAM)
            )
            print(
                "   Stream .... size=%ix%i  framerate=%i fps"
                "  STREAM_STOP_SEC=%.2f  QuickPic=%s"
                % (
                    stream_width,
                    stream_height,
                    STREAM_FPS,
                    STREAM_STOP_SEC,
                    MOTION_TRACK_QUICK_PIC_ON,
                )
            )
            print(
                "   Img Path .. MOTION_PATH=%s  MOTION_CAM_SLEEP=%.2f sec"
                % (MOTION_PATH, MOTION_CAM_SLEEP)
            )
            print(
                "   Sched ..... MOTION_START_AT %s blank=Off or"
                " Set Valid Date and/or Time to Start Sequence" % MOTION_START_AT
            )
            print(
                "   Force ..... MOTION_FORCE_SEC=%i min (If No Motion)"
                % (MOTION_FORCE_SEC / 60)
            )
            print(
                "   Lockfile .. On=%s  Path=%s  NOTE: For Motion Images Only."
                % (CREATE_LOCKFILE, LOCK_FILEPATH)
            )

            if MOTION_NUM_ON:
                print(
                    "   Num Seq ... MOTION_NUM_ON=%s  numRecycle=%s"
                    "  numStart=%i   numMax=%i  current=%s"
                    % (
                        MOTION_NUM_ON,
                        MOTION_NUM_RECYCLE_ON,
                        MOTION_NUM_START,
                        MOTION_NUM_MAX,
                        motioncount,
                    )
                )
                print("   Num Path .. NUM_PATH_MOTION=%s " % (NUM_PATH_MOTION))
            else:
                print(
                    "   Date-Time.. MOTION_NUM_ON=%s  Image Numbering is Disabled"
                    % (MOTION_NUM_ON)
                )
            if MOTION_TRACK_MINI_TL_ON:
                print(
                    "   Quick TL .. MOTION_TRACK_MINI_TL_ON=%s   MOTION_TRACK_MINI_TL_SEQ_SEC=%i"
                    " sec  MOTION_TRACK_MINI_TL_TIMER_SEC=%i sec (0=fastest)"
                    % (
                        MOTION_TRACK_MINI_TL_ON,
                        MOTION_TRACK_MINI_TL_SEQ_SEC,
                        MOTION_TRACK_MINI_TL_TIMER_SEC,
                    )
                )
            else:
                print(
                    "   Quick TL .. MOTION_TRACK_MINI_TL_ON=%s  Quick Time Lapse Disabled"
                    % MOTION_TRACK_MINI_TL_ON
                )
            if MOTION_VIDEO_ON:
                print(
                    "   Video ..... MOTION_VIDEO_ON=%s   MOTION_VIDEO_TIMER_SEC=%i"
                    " sec  MOTION_VIDEO_FPS=%i (superseded by QuickTL)"
                    % (MOTION_VIDEO_ON, MOTION_VIDEO_TIMER_SEC, MOTION_VIDEO_FPS)
                )
            else:
                print(
                    "   Video ..... MOTION_VIDEO_ON=%s  Motion Video is Disabled"
                    % MOTION_VIDEO_ON
                )
            print(
                "   Sub-Dir ... MOTION_SUBDIR_MAX_HOURS=%i (0-off)"
                "  MOTION_SUBDIR_MAX_FILES=%i (0=off)"
                % (MOTION_SUBDIR_MAX_HOURS, MOTION_SUBDIR_MAX_FILES)
            )
            print(
                "   Recent .... MOTION_RECENT_MAX=%i (0=off)  MOTION_RECENT_DIR=%s"
                % (MOTION_RECENT_MAX, MOTION_RECENT_DIR)
            )
        else:
            print(
                "Motion ....... MOTION_TRACK_ON=%s  Motion Tracking is Disabled)"
                % MOTION_TRACK_ON
            )
        print("")
        if TIMELAPSE_ON:
            print(
                "Time Lapse ... On=%s  Prefix=%s   Timer=%i sec"
                "   TIMELAPSE_EXIT_SEC=%i (0=Continuous)"
                % (
                    TIMELAPSE_ON,
                    TIMELAPSE_PREFIX,
                    TIMELAPSE_TIMER_SEC,
                    TIMELAPSE_EXIT_SEC,
                )
            )
            print("               TIMELAPSE_MAX_FILES=%i" % (TIMELAPSE_MAX_FILES))
            print(
                "   Img Path .. TIMELAPSE_PATH=%s  TIMELAPSE_CAM_SLEEP_SEC=%.2f sec"
                % (TIMELAPSE_PATH, TIMELAPSE_CAM_SLEEP_SEC)
            )
            print(
                "   Sched ..... TIMELAPSE_START_AT %s blank=Off or"
                " Set Valid Date and/or Time to Start Sequence" % TIMELAPSE_START_AT
            )
            if TIMELAPSE_NUM_ON:
                print(
                    "   Num Seq ... On=%s  numRecycle=%s  numStart=%i   numMax=%i  current=%s"
                    % (
                        TIMELAPSE_NUM_ON,
                        TIMELAPSE_NUM_RECYCLE_ON,
                        TIMELAPSE_NUM_START,
                        TIMELAPSE_NUM_MAX,
                        timelapsecount,
                    )
                )
                print("   Num Path .. numPath=%s" % (NUM_PATH_TIMELAPSE))
            else:
                print(
                    "   Date-Time.. MOTION_NUM_ON=%s  Numbering Disabled"
                    % TIMELAPSE_NUM_ON
                )
            print(
                "   Sub-Dir ... TIMELAPSE_SUBDIR_MAX_HOURS=%i (0=off)"
                "  TIMELAPSE_SUBDIR_MAX_FILES=%i (0=off)"
                % (TIMELAPSE_SUBDIR_MAX_HOURS, TIMELAPSE_SUBDIR_MAX_FILES)
            )
            print(
                "   Recent .... TIMELAPSE_RECENT_MAX=%i (0=off)  TIMELAPSE_RECENT_DIR=%s"
                % (TIMELAPSE_RECENT_MAX, TIMELAPSE_RECENT_DIR)
            )
        else:
            print(
                "Time Lapse ... TIMELAPSE_ON=%s  Timelapse is Disabled" % TIMELAPSE_ON
            )
        print("")
        if SPACE_TIMER_HOURS > 0:  # Check if disk mgmnt is enabled
            print(
                "Disk Space  .. Enabled - Manage Target Free Disk Space."
                " Delete Oldest %s Files if Required" % (SPACE_TARGET_EXT)
            )
            print(
                "               Check Every SPACE_TIMER_HOURS=%i (0=off)"
                "  Target SPACE_TARGET_MB=%i (min=100 MB)  SPACE_TARGET_EXT=%s"
                % (SPACE_TIMER_HOURS, SPACE_TARGET_MB, SPACE_TARGET_EXT)
            )
            print(
                "               Delete Oldest SPACE_TARGET_EXT=%s  SPACE_MEDIA_DIR=%s"
                % (SPACE_TARGET_EXT, SPACE_MEDIA_DIR)
            )
        else:
            print(
                "Disk Space  .. SPACE_TIMER_HOURS=%i "
                "(Disabled) - Manage Target Free Disk Space. Delete Oldest %s Files"
                % (SPACE_TIMER_HOURS, SPACE_TARGET_EXT)
            )
            print(
                "            .. Check Every SPACE_TIMER_HOURS=%i (0=Off)"
                "  Target SPACE_TARGET_MB=%i (min=100 MB)"
                % (SPACE_TIMER_HOURS, SPACE_TARGET_MB)
            )
        print("")
        print("Logging ...... VERBOSE_ON=%s (True=Enabled False=Disabled)" % VERBOSE_ON)
        print(
            "   Log Path .. LOG_TO_FILE_ON=%s  LOG_FILE_PATH=%s"
            % (LOG_TO_FILE_ON, LOG_FILE_PATH)
        )
        print(
            "--------------------------------- Log Activity "
            "---------------------------------"
        )
    checkConfig()


# ------------------------------------------------------------------------------
def getLastSubdir(directory):
    """Scan for directories and return most recent"""
    dirList = [
        name
        for name in os.listdir(directory)
        if os.path.isdir(os.path.join(directory, name))
    ]
    if len(dirList) > 0:
        lastSubDir = sorted(dirList)[-1]
        lastSubDir = os.path.join(directory, lastSubDir)
    else:
        lastSubDir = directory
    return lastSubDir


# ------------------------------------------------------------------------------
def createSubdir(directory, prefix):
    """
    Create a subdirectory in directory with
    unique name based on prefix and date time
    """
    now = datetime.datetime.now()
    # Specify folder naming
    subDirName = "%s%d-%02d%02d-%02d%02d" % (
        prefix,
        now.year,
        now.month,
        now.day,
        now.hour,
        now.minute,
    )
    subDirPath = os.path.join(directory, subDirName)
    if not os.path.isdir(subDirPath):
        try:
            os.makedirs(subDirPath)
        except OSError as err:
            logging.error(
                "Cannot Create Directory %s - %s, using default location.",
                subDirPath,
                err,
            )
            subDirPath = directory
        else:
            logging.info("Created %s", subDirPath)
    else:
        subDirPath = directory
    return subDirPath


# ------------------------------------------------------------------------------
def subDirCheckMaxFiles(directory, filesMax):
    """Count number of files in a folder path"""
    fileList = glob.glob(directory + "/*jpg")
    count = len(fileList)
    if count > filesMax:
        makeNewDir = True
        logging.info("Total Files in %s Exceeds %i", directory, filesMax)
    else:
        makeNewDir = False
    return makeNewDir


# ------------------------------------------------------------------------------
def subDirCheckMaxHrs(directory, hrsMax, prefix):
    """
    Note to self need to add error checking
    extract the date-time from the directory name
    """
    dirName = os.path.split(directory)[1]  # split dir path and keep dirName
    # remove prefix from dirName so just date-time left
    dirStr = dirName.replace(prefix, "")
    # convert string to datetime
    dirDate = datetime.datetime.strptime(dirStr, "%Y-%m%d-%H%M")
    rightNow = datetime.datetime.now()  # get datetime now
    diff = rightNow - dirDate  # get time difference between dates
    days, seconds = diff.days, diff.seconds
    dirAgeHours = float(days * 24 + (seconds / 3600.0))  # convert to hours
    if dirAgeHours > hrsMax:  # See if hours are exceeded
        makeNewDir = True
        logging.info("MaxHrs %i Exceeds %i for %s", dirAgeHours, hrsMax, directory)
    else:
        makeNewDir = False
    return makeNewDir


# ------------------------------------------------------------------------------
def subDirChecks(maxHours, maxFiles, directory, prefix):
    """Check if motion SubDir needs to be created"""
    if maxHours < 1 and maxFiles < 1:  # No Checks required
        # logging.info('No sub-folders Required in %s', directory)
        subDirPath = directory
    else:
        subDirPath = getLastSubdir(directory)
        if subDirPath == directory:  # No subDir Found
            logging.info("No sub folders Found in %s", directory)
            subDirPath = createSubdir(directory, prefix)
        # Check MaxHours Folder Age Only
        elif maxHours > 0 and maxFiles < 1:
            if subDirCheckMaxHrs(subDirPath, maxHours, prefix):
                subDirPath = createSubdir(directory, prefix)
        elif maxHours < 1 and maxFiles > 0:  # Check Max Files Only
            if subDirCheckMaxFiles(subDirPath, maxFiles):
                subDirPath = createSubdir(directory, prefix)
        elif maxHours > 0 and maxFiles > 0:  # Check both Max Files and Age
            if subDirCheckMaxHrs(subDirPath, maxHours, prefix):
                if subDirCheckMaxFiles(subDirPath, maxFiles):
                    subDirPath = createSubdir(directory, prefix)
                else:
                    logging.info("MaxFiles Not Exceeded in %s", subDirPath)
    os.path.abspath(subDirPath)
    return subDirPath


# ------------------------------------------------------------------------------
def makeMediaDir(dir_path):
    """Create a folder sequence"""
    make_dir = False
    if not os.path.isdir(dir_path):
        make_dir = True
        logging.info("Create Folder %s", dir_path)
        try:
            os.makedirs(dir_path)
        except OSError as err:
            logging.error("Could Not Create %s - %s", dir_path, err)
            sys.exit(1)
    return make_dir


# ------------------------------------------------------------------------------
def checkMediaPaths():
    """
    Checks for image folders and
    create them if they do not already exist.
    """
    makeMediaDir(DATA_DIR)

    if MOTION_TRACK_ON:
        if makeMediaDir(MOTION_PATH):
            if os.path.isfile(NUM_PATH_MOTION):
                logging.info("Delete Motion dat File %s", NUM_PATH_MOTION)
                os.remove(NUM_PATH_MOTION)
    if TIMELAPSE_ON:
        if makeMediaDir(TIMELAPSE_PATH):
            if os.path.isfile(NUM_PATH_TIMELAPSE):
                logging.info("Delete TimeLapse dat file %s", NUM_PATH_TIMELAPSE)
                os.remove(NUM_PATH_TIMELAPSE)
    # Check for Recent Image Folders and create if they do not already exist.
    if MOTION_RECENT_MAX > 0:
        makeMediaDir(MOTION_RECENT_DIR)
    if TIMELAPSE_RECENT_MAX > 0:
        makeMediaDir(TIMELAPSE_RECENT_DIR)
    if PANTILT_SEQ_ON:
        makeMediaDir(PANTILT_SEQ_IMAGES_DIR)
        if PANTILT_SEQ_RECENT_MAX > 0:
            makeMediaDir(PANTILT_SEQ_RECENT_DIR)
    if PANO_ON:
        makeMediaDir(PANO_DIR)
        makeMediaDir(PANO_IMAGES_DIR)


# ------------------------------------------------------------------------------
def deleteOldFiles(maxFiles, dirPath, prefix):
    """
    Delete Oldest files gt or eq to maxfiles that match filename prefix
    """
    try:
        fileList = sorted(
            glob.glob(os.path.join(dirPath, prefix + "*")), key=os.path.getmtime
        )
    except OSError as err:
        logging.error("Problem Reading Directory %s - %s", dirPath, err)
    else:
        while len(fileList) >= maxFiles:
            oldest = fileList[0]
            oldestFile = oldest
            try:  # Remove oldest file in recent folder
                fileList.remove(oldest)
                logging.info("%s", oldestFile)
                os.remove(oldestFile)
            except OSError as err:
                logging.error("Failed %s  err: %s", oldestFile, err)


# ------------------------------------------------------------------------------


def makeRelSymlink(sourceFilenamePath, symDestDir):
    """
    Creates a relative symlink in the specified symDestDir
    that points to the Target file via a relative rather than
    absolute path. If a symlink already exists it will be replaced.
    Warning message will be displayed if symlink path is a file
    rather than an existing symlink.
    """

    # Initialize target and symlink file paths
    targetDirPath = os.path.dirname(sourceFilenamePath)
    srcfilename = os.path.basename(sourceFilenamePath)
    symDestFilePath = os.path.join(symDestDir, srcfilename)
    # Check if symlink already exists and unlink if required.
    if os.path.islink(symDestFilePath):
        logging.info("Remove Existing Symlink at %s ", symDestFilePath)
        os.unlink(symDestFilePath)
    # Check if symlink path is a file rather than a symlink. Error out if required
    if os.path.isfile(symDestFilePath):
        logging.warning("Failed. File Exists at %s." % symDestFilePath)
        return

    # Initialize required entries for creating a relative symlink to target file
    absTargetDirPath = os.path.abspath(targetDirPath)
    absSymDirPath = os.path.abspath(symDestDir)
    relativeDirPath = os.path.relpath(absTargetDirPath, absSymDirPath)
    # Initialize relative symlink entries to target file.

    symFilePath = os.path.join(relativeDirPath, srcfilename)
    # logging.info("ln -s %s %s ", symFilePath, symDestFilePath)
    os.symlink(symFilePath, symDestFilePath)  # Create the symlink
    # Check if symlink was created successfully
    if os.path.islink(symDestFilePath):
        logging.info("Saved at %s", symDestFilePath)
    else:
        logging.warning("Failed to Create Symlink at %s", symDestFilePath)


# ------------------------------------------------------------------------------
def saveRecent(recentMax, recentDir, filepath, prefix):
    """
    Create a symlink file in recent folder (timelapse or motion subfolder)
    Delete Oldest symlink file if recentMax exceeded.
    """
    show_log = False
    if recentMax > 0:
        deleteOldFiles(recentMax, os.path.abspath(recentDir), prefix)
        makeRelSymlink(filepath, recentDir)


# ------------------------------------------------------------------------------
def filesToDelete(mediaDirPath, extension=IMAGE_FORMAT):
    """
    Deletes files of specified format extension
    by walking folder structure from specified mediaDirPath
    """
    return sorted(
        (
            os.path.join(dirname, filename)
            for dirname, dirnames, filenames in os.walk(mediaDirPath)
            for filename in filenames
            if filename.endswith(extension)
        ),
        key=lambda fn: os.stat(fn).st_mtime,
        reverse=True,
    )


# ------------------------------------------------------------------------------
def freeSpaceUpTo(freeMB, mediaDir, extension=IMAGE_FORMAT):
    """
    Walks mediaDir and deletes oldest files until SPACE_TARGET_MB is achieved.
    You should Use with Caution this feature.
    """
    mediaDirPath = os.path.abspath(mediaDir)
    if os.path.isdir(mediaDirPath):
        MB2Bytes = 1048576  # Conversion from MB to Bytes
        targetFreeBytes = freeMB * MB2Bytes
        fileList = filesToDelete(mediaDir, extension)
        totFiles = len(fileList)
        delcnt = 0
        logging.info("Session Started")
        while fileList:
            statv = os.statvfs(mediaDirPath)
            availFreeBytes = statv.f_bfree * statv.f_bsize
            if availFreeBytes >= targetFreeBytes:
                break
            filePath = fileList.pop()
            try:
                os.remove(filePath)
            except OSError as err:
                logging.error("Del Failed %s", filePath)
                logging.error("Error is %s", err)
            else:
                delcnt += 1
                logging.info("Del %s", filePath)
                logging.info(
                    "Target=%i MB  Avail=%i MB  Deleted %i of %i Files ",
                    targetFreeBytes / MB2Bytes,
                    availFreeBytes / MB2Bytes,
                    delcnt,
                    totFiles,
                )
                # Avoid deleting more than 1/4 of files at one time
                if delcnt > totFiles / 4:
                    logging.warning("Max Deletions Reached %i of %i", delcnt, totFiles)
                    logging.warning(
                        "Deletions Restricted to 1/4 of " "total files per session."
                    )
                    break
        logging.info("Session Ended")
    else:
        logging.error("Directory Not Found - %s", mediaDirPath)


# ------------------------------------------------------------------------------
def freeDiskSpaceCheck(lastSpaceCheck):
    """
    Perform Disk space checking and Clean up
    if enabled and return datetime done
    to reset ready for next sched date/time
    """
    if SPACE_TIMER_HOURS > 0:  # Check if disk free space timer hours is enabled
        # See if it is time to do disk clean-up check
        if (
            datetime.datetime.now() - lastSpaceCheck
        ).total_seconds() > SPACE_TIMER_HOURS * 3600:
            lastSpaceCheck = datetime.datetime.now()
            if SPACE_TARGET_MB < 100:  # set freeSpaceMB to reasonable value if too low
                diskFreeMB = 100
            else:
                diskFreeMB = SPACE_TARGET_MB
            logging.info(
                "SPACE_TIMER_HOURS=%i  diskFreeMB=%i  SPACE_MEDIA_DIR=%s SPACE_TARGET_EXT=%s",
                SPACE_TIMER_HOURS,
                diskFreeMB,
                SPACE_MEDIA_DIR,
                SPACE_TARGET_EXT,
            )
            freeSpaceUpTo(diskFreeMB, SPACE_MEDIA_DIR, SPACE_TARGET_EXT)
    return lastSpaceCheck


# ------------------------------------------------------------------------------
def getCurrentCount(numberpath, numberstart):
    """
    Create a .dat file to store currentCount
    or read file if it already Exists
    """
    if not os.path.isfile(numberpath):
        # Create numberPath file if it does not exist
        logging.info("Creating New File %s numberstart= %s", numberpath, numberstart)
        open(numberpath, "w").close()
        f = open(numberpath, "w+")
        f.write(str(numberstart))
        f.close()
    # Read the numberPath file to get the last sequence number
    with open(numberpath, "r") as f:
        writeCount = f.read()
        f.closed
        try:
            numbercounter = int(writeCount)
        # Found Corrupt dat file since cannot convert to integer
        except ValueError:
            # Try to determine if this is motion or timelapse
            if numberpath.find(MOTION_PREFIX) > 0:
                filePath = MOTION_PATH + "/*" + IMAGE_FORMAT
                fprefix = MOTION_PATH + MOTION_PREFIX + IMAGE_NAME_PREFIX
            else:
                filePath = TIMELAPSE_PATH + "/*" + IMAGE_FORMAT
                fprefix = TIMELAPSE_PATH + TIMELAPSE_PREFIX + IMAGE_NAME_PREFIX
            try:
                # Scan image folder for most recent file
                # and try to extract most recent number counter
                newest = max(glob.iglob(filePath), key=os.path.getctime)
                writeCount = newest[len(fprefix) + 1 : newest.find(IMAGE_FORMAT)]
            except:
                writeCount = numberstart
            try:
                numbercounter = int(writeCount) + 1
            except ValueError:
                numbercounter = numberstart
            logging.warning(
                "Found Invalid Data in %s Resetting Counter to %s",
                numberpath,
                numbercounter,
            )
        f = open(numberpath, "w+")
        f.write(str(numbercounter))
        f.close()
        f = open(numberpath, "r")
        writeCount = f.read()
        f.close()
        numbercounter = int(writeCount)
    return numbercounter


# ------------------------------------------------------------------------------
def writeTextToImage(imagename, datetoprint, currentDayMode):
    """
    Function to write date/time stamp
    directly on top or bottom of images.
    """
    if SHOW_TEXT_WHITE:
        FOREGROUND = (255, 255, 255)  # rgb settings for white text foreground
        textColour = "White"
    else:
        FOREGROUND = (0, 0, 0)  # rgb settings for black text foreground
        textColour = "Black"
        if SHOW_TEXT_WHITE_NIGHT and (not currentDayMode):
            # rgb settings for black text foreground
            FOREGROUND = (255, 255, 255)
            textColour = "White"
    img = cv2.imread(imagename)
    # This is grayscale image so channels is not avail or used
    height, width, channels = img.shape
    # centre text and compensate for graphics text being wider
    x = int((width / 2) - (len(imagename) * 2))
    if SHOW_TEXT_BOTTOM:
        y = height - 50  # show text at bottom of image
    else:
        y = 10  # show text at top of image
    TEXT = IMAGE_NAME_PREFIX + datetoprint
    font_path = "/usr/share/fonts/truetype/freefont/FreeSansBold.ttf"
    font = ImageFont.truetype(font_path, SHOW_TEXT_FONT_SIZE, encoding="unic")
    try:
        text = TEXT.decode("utf-8")  # required for python2
    except:
        text = TEXT  # Just set for python3
    img = Image.open(imagename)
    # For python3 install of pyexiv2 lib
    # See https://github.com/pageauc/pi-timolo/issues/79

    try:  # Read exif data since ImageDraw does not save this metadata
        metadata = pyexiv2.ImageMetadata(imagename)
        metadata.read()
    except:
        pass
    draw = ImageDraw.Draw(img)
    # draw.text((x, y),"Sample Text",(r,g,b))
    draw.text((x, y), text, FOREGROUND, font=font)
    if IMAGE_FORMAT.lower == ".jpg" or IMAGE_FORMAT.lower == ".jpeg":
        img.save(imagename, quality="keep")
    else:
        img.save(imagename)
    logging.info("Added %s Text [ %s ]", textColour, datetoprint)
    try:
        metadata.write()  # Write previously saved exif data to image file
    except:
        logging.warning("Image EXIF Data Not Transferred.")
    logging.info("Saved %s", imagename)


# ------------------------------------------------------------------------------
def writeCounter(counter, counter_path):
    """
    Write next counter number
    to specified counter_path dat file
    to remember where counter is to start next in case
    app shuts down.
    """
    str_count = str(counter)
    if not os.path.isfile(counter_path):
        logging.info("Create New Counter File Counter=%s %s", str_count, counter_path)
        open(counter_path, "w").close()
    f = open(counter_path, "w+")
    f.write(str_count)
    f.close()
    logging.info("Next Counter=%s %s", str_count, counter_path)


# ------------------------------------------------------------------------------
def postImageProcessing(
    numberon,
    counterstart,
    countermax,
    counter,
    recycle,
    counterpath,
    filename,
    currentDaymode,
):
    """
    If required process text to display directly on image
    """
    rightNow = datetime.datetime.now()
    if SHOW_DATE_ON_IMAGE:
        dateTimeText = "%04d%02d%02d_%02d:%02d:%02d" % (
            rightNow.year,
            rightNow.month,
            rightNow.day,
            rightNow.hour,
            rightNow.minute,
            rightNow.second,
        )
        if numberon:
            if not recycle and countermax > 0:
                counterStr = "%i/%i " % (counter, counterstart + countermax)
                imageText = counterStr + dateTimeText
            else:
                counterStr = "%i  " % (counter)
                imageText = counterStr + dateTimeText
        else:
            imageText = dateTimeText
        # Now put the imageText on the current image
        try:  # This will fail for a video file
            writeTextToImage(filename, imageText, currentDaymode)
        except:
            pass
    if CREATE_LOCKFILE and MOTION_TRACK_ON:
        createSyncLockFile(filename)
    # Process currentCount for next image if number sequence is enabled
    if numberon:
        counter += 1
        if countermax > 0:
            if counter >= counterstart + countermax:
                if recycle:
                    counter = counterstart
                else:
                    counter = counterstart + countermax + 1
                    logging.warning(
                        "Exceeded Image Count numberMax=%i for %s \n",
                        countermax,
                        filename,
                    )
        # write next image counter number to dat file
        writeCounter(counter, counterpath)
    return counter


# ------------------------------------------------------------------------------
def getVideoName(path, prefix, numberon, counter):
    """build image file names by number sequence or date/time"""
    if numberon:
        if MOTION_VIDEO_ON or VIDEO_REPEAT_ON:
            filename = os.path.join(path, prefix + str(counter) + ".h264")
    else:
        if MOTION_VIDEO_ON or VIDEO_REPEAT_ON:
            rightNow = datetime.datetime.now()
            filename = "%s/%s%04d%02d%02d-%02d%02d%02d.h264" % (
                path,
                prefix,
                rightNow.year,
                rightNow.month,
                rightNow.day,
                rightNow.hour,
                rightNow.minute,
                rightNow.second,
            )
    return filename


# ------------------------------------------------------------------------------
def getImageFilename(path, prefix, numberon, counter):
    """build image file names by number sequence or date/time"""
    if numberon:
        filename = os.path.join(path, prefix + str(counter) + IMAGE_FORMAT)
    else:
        rightNow = datetime.datetime.now()
        filename = "%s/%s%04d%02d%02d-%02d%02d%02d%s" % (
            path,
            prefix,
            rightNow.year,
            rightNow.month,
            rightNow.day,
            rightNow.hour,
            rightNow.minute,
            rightNow.second,
            IMAGE_FORMAT,
        )
    return filename


# ------------------------------------------------------------------------------
def showBox(filename):
    """
    Show stream image detection area on image to align camera
    This is a quick fix for restricting motion detection
    to a portion of the final image. Change the stream image size
    on line 206 and 207 above
    Adjust track config.py file MOTION_TRACK_TRIG_LEN as required.
    """
    working_image = cv2.imread(filename)
    x1y1 = (
        int((IMAGE_WIDTH - stream_width) / 2),
        int((image_height - stream_height) / 2),
    )
    x2y2 = (x1y1[0] + stream_width, x1y1[1] + stream_height)
    cv2.rectangle(working_image, x1y1, x2y2, LINE_COLOR, LINE_THICKNESS)
    cv2.imwrite(filename, working_image)


# ------------------------------------------------------------------------------
def takeMotionQuickImage(image, filename):
    """Enlarge and Save stream image if MOTION_TRACK_QUICK_PIC_ON=True"""
    big_image = (
        cv2.resize(image, (bigImageWidth, bigImageHeight)) if bigImage != 1 else image
    )
    cv2.imwrite(filename, big_image)
    logging.info("Saved %ix%i Image to %s", bigImageWidth, bigImageHeight, filename)


# ------------------------------------------------------------------------------
def takeDayImage(filename, cam_sleep_time):
    """Take a Day image using exp=auto and awb=auto"""
    with picamera.PiCamera() as camera:
        camera.resolution = (image_width, image_height)
        camera.vflip = IMAGE_VFLIP
        camera.hflip = IMAGE_HFLIP
        camera.rotation = IMAGE_ROTATION  # Valid values are 0, 90, 180, 270
        # Day Automatic Mode
        camera.exposure_mode = "auto"
        camera.awb_mode = "auto"
        if IMAGE_GRAYSCALE:
            camera.color_effects = (128, 128)
        time.sleep(cam_sleep_time)  # use motion or TL camera sleep to get AWB
        if IMAGE_PREVIEW:
            camera.start_preview()
        if IMAGE_FORMAT == ".jpg":  # Set quality if image is jpg
            camera.capture(filename, quality=IMAGE_JPG_QUAL)
        else:
            camera.capture(filename)
        camera.close()
    if IMAGE_SHOW_STREAM:  # Show motion area on full image to align camera
        showBox(filename)
    logging.info(
        "camSleepSec=%.2f exp=auto awb=auto Size=%ix%i ",
        cam_sleep_time,
        image_width,
        image_height,
    )
    # SHOW_DATE_ON_IMAGE displays FilePath so avoid showing twice
    if not SHOW_DATE_ON_IMAGE:
        logging.info("Saved  %s", filename)


# ------------------------------------------------------------------------------
def getShutterSetting(pxAve):
    """
    Calculate a shutter speed based on image pixel average
    """
    px = pxAve + 1  # avoid division by zero
    offset = NIGHT_MAX_SHUTTER - (
        (NIGHT_MAX_SHUTTER / float(NIGHT_DARK_THRESHOLD) * px)
    )
    brightness = offset * (1 / float(NIGHT_DARK_ADJUST))
    # hyperbolic curve + brightness adjust
    shut = (NIGHT_MAX_SHUTTER * (1 / float(px))) + brightness
    return int(shut)


# ------------------------------------------------------------------------------
def takeNightImage(filename, pixelAve):
    """Take low light Twilight or Night image"""
    with picamera.PiCamera() as camera:
        camera.resolution = (image_width, image_height)
        camera.vflip = IMAGE_VFLIP
        camera.hflip = IMAGE_HFLIP
        camera.rotation = IMAGE_ROTATION  # valid values are 0, 90, 180, 270
        if IMAGE_GRAYSCALE:
            camera.color_effects = (128, 128)
        # Use Twilight Threshold variable framerate_range
        if pixelAve >= NIGHT_DARK_THRESHOLD:
            camera.framerate_range = (Fraction(1, 6), Fraction(30, 1))
            time.sleep(1)
            camera.iso = NIGHT_MAX_ISO
            logging.info(
                "%ix%i  TwilightThresh=%i/%i  MaxISO=%i uses framerate_range",
                image_width,
                image_height,
                pixelAve,
                NIGHT_TWILIGHT_THRESHOLD,
                NIGHT_MAX_ISO,
            )
            time.sleep(4)
        else:
            # Set the framerate to a fixed value
            camera.framerate = Fraction(1, 6)
            time.sleep(1)
            camera.iso = NIGHT_MAX_ISO
            if pixelAve <= NIGHT_BLACK_THRESHOLD:  # Black Threshold (very dark)
                camera.shutter_speed = NIGHT_MAX_SHUTTER
                logging.info(
                    "%ix%i  BlackThresh=%i/%i shutSec=%s  MaxISO=%i  NIGHT_SLEEP_SEC=%i",
                    image_width,
                    image_height,
                    pixelAve,
                    NIGHT_BLACK_THRESHOLD,
                    shut2sec(NIGHT_MAX_SHUTTER),
                    NIGHT_MAX_ISO,
                    NIGHT_SLEEP_SEC,
                )
            else:  # Dark Threshold (Between Twilight and Black)
                camShut = getShutterSetting(pixelAve)
                if camShut > NIGHT_MAX_SHUTTER:
                    camShut = NIGHT_MAX_SHUTTER
                # Set the shutter for long exposure
                camera.shutter_speed = camShut
                logging.info(
                    "%ix%i  DarkThresh=%i/%i  shutSec=%s  MaxISO=%i  NIGHT_SLEEP_SEC=%i",
                    image_width,
                    image_height,
                    pixelAve,
                    NIGHT_DARK_THRESHOLD,
                    shut2sec(camShut),
                    NIGHT_MAX_ISO,
                    NIGHT_SLEEP_SEC,
                )
            time.sleep(NIGHT_SLEEP_SEC)
            camera.exposure_mode = "off"
        if IMAGE_FORMAT == ".jpg":
            camera.capture(filename, format="jpeg", quality=IMAGE_JPG_QUAL)
        else:
            camera.capture(filename)
        camera.framerate = 10  # Adhoc Fix for Stretch camera freeze issue
        # Perform sudo rpi-update
        camera.close()
    if IMAGE_SHOW_STREAM:  # Show motion area on full image to align camera
        showBox(filename)
    # SHOW_DATE_ON_IMAGE displays FilePath to avoid showing twice
    if not SHOW_DATE_ON_IMAGE:
        logging.info("Saved %s", filename)


# ------------------------------------------------------------------------------
def createSyncLockFile(imagefilename):
    """
    If required create a lock file to indicate file(s) to process
    """
    if CREATE_LOCKFILE:
        if not os.path.isfile(LOCK_FILEPATH):
            open(LOCK_FILEPATH, "w").close()
            logging.info("Create Lock File %s", LOCK_FILEPATH)
        rightNow = datetime.datetime.now()
        now = "%04d%02d%02d-%02d%02d%02d" % (
            rightNow.year,
            rightNow.month,
            rightNow.day,
            rightNow.hour,
            rightNow.minute,
            rightNow.second,
        )
        filecontents = (
            now
            + " createSyncLockFile - "
            + imagefilename
            + " Ready to sync using sudo ./sync.sh command."
        )
        f = open(LOCK_FILEPATH, "w+")
        f.write(filecontents)
        f.close()


# ------------------------------------------------------------------------------
def getMotionTrackPoint(grayimage1, grayimage2):
    """
    Process two cropped grayscale images.
    check for motion and return center point
    of motion for largest contour.
    """
    movementCenterPoint = []  # initialize list of movementCenterPoints
    biggestArea = MIN_AREA
    # Get differences between the two greyed images
    differenceimage = cv2.absdiff(grayimage1, grayimage2)
    # Blur difference image to enhance motion vectors
    differenceimage = cv2.blur(differenceimage, (BLUR_SIZE, BLUR_SIZE))
    # Get threshold of blurred difference image
    # based on THRESHOLD_SENSITIVITY variable
    retval, thresholdimage = cv2.threshold(
        differenceimage, THRESHOLD_SENSITIVITY, 255, cv2.THRESH_BINARY
    )
    try:
        # opencv2 syntax default
        contours, hierarchy = cv2.findContours(
            thresholdimage, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
        )
    except ValueError:
        # opencv 3 syntax
        thresholdimage, contours, hierarchy = cv2.findContours(
            thresholdimage, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
        )
    if contours:
        for c in contours:
            cArea = cv2.contourArea(c)
            if cArea > biggestArea:
                biggestArea = cArea
                (x, y, w, h) = cv2.boundingRect(c)
                cx = int(x + w / 2)  # x center point of contour
                cy = int(y + h / 2)  # y center point of contour
                movementCenterPoint = [cx, cy]
    return movementCenterPoint


# ------------------------------------------------------------------------------
def trackMotionDistance(mPoint1, mPoint2):
    """
    Return the triangulated distance between two tracking locations
    """
    x1, y1 = mPoint1
    x2, y2 = mPoint2
    trackLen = abs(math.hypot(x2 - x1, y2 - y1))
    return trackLen


# ------------------------------------------------------------------------------
def getStreamPixAve(streamData):
    """
    Calculate the average pixel values for the specified stream
    used for determining day/night or twilight conditions
    """
    pixAverage = int(np.average(streamData[..., 1]))  # Use 0=red 1=green 2=blue
    return pixAverage


# ------------------------------------------------------------------------------
def checkIfDayStream(currentDayMode, image):
    """Try to determine if it is day, night or twilight."""
    dayPixAverage = 0
    currentDayMode = False
    dayPixAverage = getStreamPixAve(image)
    if dayPixAverage > NIGHT_TWILIGHT_THRESHOLD:
        currentDayMode = True
    return currentDayMode


# ------------------------------------------------------------------------------
def timeToSleep(currentDayMode):
    """
    Based on weather it is day or night (exclude twilight)
    return sleepMode boolean based on variable
    settings for IMAGE_NO_NIGHT_SHOTS or IMAGE_NO_DAY_SHOTS config.py variables
    Note if both are enabled then no shots will be taken.
    """
    if IMAGE_NO_NIGHT_SHOTS:
        if currentDayMode:
            sleepMode = False
        else:
            sleepMode = True
    elif IMAGE_NO_DAY_SHOTS:
        sleepMode = False
        if currentDayMode:
            sleepMode = True
    else:
        sleepMode = False
    return sleepMode


# ------------------------------------------------------------------------------
def getSchedStart(dateToCheck):
    """
    This function will try to extract a valid date/time from a
    date time formatted string variable
    If date/time is past then try to extract time
    and schedule for current date at extracted time
    """
    goodDateTime = datetime.datetime.now()
    if len(dateToCheck) > 1:  # Check if TIMELAPSE_START_AT is set
        try:
            # parse and convert string to date/time or return error
            goodDateTime = parse(dateToCheck)
        except:
            # Is there a colon indicating possible time format exists
            if ":" in dateToCheck:
                timeTry = dateToCheck[dateToCheck.find(":") - 2 :]
                # Try to extract time only from string
                try:
                    # See if a valid time is found returns with current day
                    goodDateTime = parse(timeTry)
                except:
                    logging.error("Bad Date and/or Time Format %s", dateToCheck)
                    logging.error(
                        "Use a Valid Date and/or Time "
                        'Format Eg "DD-MMM-YYYY HH:MM:SS"'
                    )
                    goodDateTime = datetime.datetime.now()
                    logging.warning("Resetting date/time to Now: %s", goodDateTime)
        # Check if date/time is past
        if goodDateTime < datetime.datetime.now():
            if ":" in dateToCheck:  # Check if there is a time component
                # Extract possible time component
                timeTry = dateToCheck[dateToCheck.find(":") - 2 :]
                try:
                    # parse for valid time
                    # returns current day with parsed time
                    goodDateTime = parse(timeTry)
                except:
                    pass  # Do Nothing
    return goodDateTime


# ------------------------------------------------------------------------------
def checkSchedStart(schedDate):
    """
    Based on schedule date setting see if current
    datetime is past and return boolean
    to indicate processing can start for
    timelapse or motiontracking
    """
    startStatus = False
    if schedDate < datetime.datetime.now():
        startStatus = True  # sched date/time has passed so start sequence
    return startStatus


# ------------------------------------------------------------------------------
def checkTimer(timer_start, timer_sec):
    """
    Check if timelapse timer has expired
    Return updated start time status of expired timer True or False
    """
    timer_expired = False
    rightNow = datetime.datetime.now()
    timeDiff = (rightNow - timer_start).total_seconds()
    if timeDiff >= timer_sec:
        timer_expired = True
        timer_start = rightNow
    return timer_start, timer_expired


# ------------------------------------------------------------------------------
def takeMiniTimelapse(moPath, prefix, NumOn, motionNumCount, currentDayMode, NumPath):
    """
    Take a motion tracking activated mini timelapse sequence
    using yield if motion triggered
    """
    logging.info(
        "START - Run for %i secs with image every %i secs",
        MOTION_TRACK_MINI_TL_SEQ_SEC,
        MOTION_TRACK_MINI_TL_TIMER_SEC,
    )
    checkTimeLapseTimer = datetime.datetime.now()
    keepTakingImages = True
    imgCnt = 0
    filename = getImageFilename(moPath, prefix, NumOn, motionNumCount)
    while keepTakingImages:
        yield filename
        rightNow = datetime.datetime.now()
        timelapseDiff = (rightNow - checkTimeLapseTimer).total_seconds()
        motionNumCount = postImageProcessing(
            NumOn,
            MOTION_NUM_START,
            MOTION_NUM_MAX,
            motionNumCount,
            MOTION_NUM_RECYCLE_ON,
            NUM_PATH_MOTION,
            filename,
            currentDayMode,
        )
        filename = getImageFilename(moPath, prefix, NumOn, motionNumCount)
        if timelapseDiff > MOTION_TRACK_MINI_TL_SEQ_SEC:
            keepTakingImages = False
        else:
            imgCnt += 1
            saveRecent(MOTION_RECENT_MAX, MOTION_RECENT_DIR, filename, prefix)
            time.sleep(MOTION_TRACK_MINI_TL_TIMER_SEC)
    logging.info(
        "END - Total %i Images in %i sec every %i sec",
        imgCnt,
        timelapseDiff,
        MOTION_TRACK_MINI_TL_TIMER_SEC,
    )
    print("")


# ------------------------------------------------------------------------------
def takeVideo(filename, duration, vidW=1280, vidH=720, fps=25):
    """Take a short motion video if required"""
    # Working folder for h264 videos
    h264_work = os.path.join(BASE_DIR, "h264_work")
    if not os.path.isdir(h264_work):
        try:
            os.makedirs(h264_work)
        except OSError as err:
            logging.error("%s  err: %s", h264_work, err)
        else:
            logging.info("Created Dir %s", h264_work)
    filePath264 = os.path.join(h264_work, os.path.basename(filename))
    # Final destination for mp4 videos
    filePathMP4 = os.path.join(
        os.path.dirname(filename),
        os.path.splitext(os.path.basename(filename))[0] + ".mp4",
    )
    # command to convert h264 video to mp4
    h264_mp4_cmd = "/usr/bin/MP4Box -add %s:fps=%i -new %s" % (
        filePath264,
        fps,
        filePathMP4,
    )
    logging.info("File : %s", filePath264)
    logging.info("Start: Size %ix%i for %i sec at %i fps", vidW, vidH, duration, fps)
    if MOTION_VIDEO_ON or VIDEO_REPEAT_ON:
        with picamera.PiCamera() as camera:
            camera.resolution = (vidW, vidH)
            camera.vflip = IMAGE_VFLIP
            camera.hflip = IMAGE_HFLIP
            # rotation can be used if camera is on side
            camera.rotation = IMAGE_ROTATION
            camera.framerate = fps
            if SHOW_DATE_ON_IMAGE:
                rightNow = datetime.datetime.now()
                dateTimeText = " Started at %04d-%02d-%02d %02d:%02d:%02d " % (
                    rightNow.year,
                    rightNow.month,
                    rightNow.day,
                    rightNow.hour,
                    rightNow.minute,
                    rightNow.second,
                )
                camera.annotate_text_size = SHOW_TEXT_FONT_SIZE
                camera.annotate_foreground = picamera.Color("black")
                camera.annotate_background = picamera.Color("white")
                camera.annotate_text = dateTimeText
            camera.start_recording(filePath264)
            camera.wait_recording(duration)
            camera.stop_recording()
            camera.close()
        # This creates a subprocess that runs MP4Box to convert h264 file
        # to MP4 with the filename as a parameter.  Note this will take
        # some time so MP4Box logging info will be delayed.
        try:
            logging.info("MP4Box %s", filePathMP4)
            proc = subprocess.Popen(
                h264_mp4_cmd,
                shell=True,
                stdin=None,
                stdout=None,
                stderr=None,
                close_fds=True,
            )
        except IOError:
            logging.error("subprocess %s", h264_mp4_cmd)
        saveRecent(MOTION_RECENT_MAX, MOTION_RECENT_DIR, filePathMP4, MOTION_PREFIX)
        createSyncLockFile(filename)


# ------------------------------------------------------------------------------
def pantiltGoHome():
    """
    Move pantilt to home position. If pantilt installed then this
    can position pantilt to a home position for consistent
    motion tracking and timelapse camera pointing.
    """
    if PANTILT_ON:
        pantilthat.pan(PANTILT_HOME[0])
        time.sleep(PANTILT_SLEEP_SEC)
        pantilthat.tilt(PANTILT_HOME[1])
        time.sleep(PANTILT_SLEEP_SEC)


# ------------------------------------------------------------------------------
def addFilepathSeq(filepath, seq_num):
    """
    Add a sequence number to the filename just prior to the image format extension.
    """
    index = filepath.find(IMAGE_FORMAT)
    seq_filepath = filepath[:index] + "-" + str(seq_num) + filepath[index:]
    return seq_filepath


# ------------------------------------------------------------------------------
def takePantiltSequence(filename, daymode, pix_ave, num_count, num_path):
    """
    Take a sequence of images based on a list of pantilt positions and save with
    a sequence number appended to the filename
    """

    if (not daymode) and PANTILT_SEQ_DAYONLY_ON:
        logging.info(
            "Skip since PANTILT_SEQ_DAYONLY_ON = %s and daymode = %s",
            PANTILT_SEQ_DAYONLY_ON,
            daymode,
        )
        return
    elif not PANTILT_ON:
        logging.error("PANTILT_ON not Enabled in Config.py")
        return

    if MOTION_TRACK_ON and MOTION_TRACK_PANTILT_SEQ_ON:
        seq_prefix = MOTION_PREFIX + IMAGE_NAME_PREFIX
        if PANTILT_SEQ_ON:
            logging.warning(
                "MOTION_TRACK_PANTILT_SEQ_ON takes precedence over PANTILT_SEQ_ON"
            )
            logging.warning("Disable config.py MOTION_TRACK_PANTILT_SEQ_ON setting")
            logging.warning("to Enable Timelapse PANTILT_SEQ_ON option.")
        logging.info("... Start Motion Tracking PanTilt Sequence.")
    elif PANTILT_SEQ_ON:
        seq_prefix = PANTILT_SEQ_IMAGE_PREFIX + IMAGE_NAME_PREFIX
        logging.info("... Start Timelapse PanTilt Sequence.")

    # initialize counter to ensure each image filename is unique
    pantilt_seq_image_num = 0

    for cam_pos in PANTILT_SEQ_STOPS:  # take images at each specified stop
        pantilt_seq_image_num += 1  # Set image numbering for this image
        seq_filepath = addFilepathSeq(filename, pantilt_seq_image_num)
        pan_x, tilt_y = cam_pos  # set pan tilt values for this image
        pantilthat.pan(pan_x)
        pantilthat.tilt(tilt_y)
        logging.info("pan_x=%i tilt_y=%i", pan_x, tilt_y)
        time.sleep(PANTILT_SLEEP_SEC)
        if daymode:
            takeDayImage(seq_filepath, TIMELAPSE_CAM_SLEEP_SEC)
        else:
            takeNightImage(seq_filepath, pix_ave)

        if MOTION_TRACK_PANTILT_SEQ_ON:
            postImageProcessing(
                MOTION_NUM_ON,
                MOTION_NUM_START,
                MOTION_NUM_MAX,
                num_count,
                MOTION_NUM_RECYCLE_ON,
                NUM_PATH_MOTION,
                seq_filepath,
                daymode,
            )
            saveRecent(MOTION_NUM_MAX, MOTION_RECENT_DIR, seq_filepath, seq_prefix)

        elif PANTILT_SEQ_ON:
            postImageProcessing(
                PANTILT_SEQ_NUM_ON,
                PANTILT_SEQ_NUM_START,
                PANTILT_SEQ_NUM_MAX,
                num_count,
                PANTILT_SEQ_NUM_RECYCLE_ON,
                NUM_PATH_PANTILT_SEQ,
                seq_filepath,
                daymode,
            )
            saveRecent(
                PANTILT_SEQ_NUM_MAX,
                PANTILT_SEQ_RECENT_DIR,
                seq_filepath,
                PANTILT_SEQ_IMAGE_PREFIX,
            )

    if PANTILT_SEQ_NUM_ON:
        num_count += 1
        writeCounter(num_count, NUM_PATH_PANTILT_SEQ)

    deleteOldFiles(
        PANTILT_SEQ_RECENT_MAX,
        os.path.abspath(PANTILT_SEQ_RECENT_DIR),
        PANTILT_SEQ_IMAGE_PREFIX,
    )
    pantiltGoHome()  # Center pantilt
    logging.info("... End")
    return num_count


# ------------------------------------------------------------------------------
def takePano(pano_seq_num, daymode, pix_ave):
    """
    Take a series of overlapping images using pantilt at specified PANO_CAM_STOPS
    then attempt to stitch the images into one panoramic image. Note this
    will take time so depending on number of cpu cores and speed. The PANO_TIMER
    should be set to avoid multiple stitching operations at once.
    use htop or top to check stitching PID activity.

    Successfuly Stitching needs good lighting so it should be restricted to
    day light hours or sufficient indoor lighting.
    Review pano source image overlap using webserver. Adjust pano stops accordingly.
    """

    if (not daymode) and PANO_DAYONLY_ON:
        logging.info(
            "Skip since PANO_DAYONLY_ON = %s and daymode = %s", PANO_DAYONLY_ON, daymode
        )
        return

    print("")
    logging.info("Start timer=%i sec  pano_seq_num=%s", PANO_TIMER_SEC, pano_seq_num)

    pano_image_num = 0  # initialize counter to ensure each image filename is unique
    pano_image_files = (
        ""  # string of contatenated image input pano filenames for stitch command line
    )
    pano_file_path = os.path.join(
        PANO_DIR,
        PANO_IMAGE_PREFIX + IMAGE_NAME_PREFIX + str(pano_seq_num) + IMAGE_FORMAT,
    )

    for cam_pos in PANO_CAM_STOPS:  # take images at each specified stop
        pano_image_num += 1  # Set image numbering for this image
        pan_x, tilt_y = cam_pos  # set pan tilt values for this image
        pano_filename = os.path.join(
            PANO_IMAGES_DIR,
            PANO_IMAGE_PREFIX
            + IMAGE_NAME_PREFIX
            + str(pano_seq_num)
            + "-"
            + str(pano_image_num)
            + IMAGE_FORMAT,
        )
        pano_image_files += " " + pano_filename
        pantilthat.pan(pan_x)
        pantilthat.tilt(tilt_y)
        if pano_seq_num == 1:
            time.sleep(0.3)
        time.sleep(PANTILT_SLEEP_SEC)
        if daymode:
            takeDayImage(pano_filename, TIMELAPSE_CAM_SLEEP_SEC)
        else:
            takeNightImage(pano_filename, pix_ave)
        logging.info(
            "Size %ix%i Saved %s at cam_pos(%i, %i)",
            image_width,
            image_height,
            pano_filename,
            pan_x,
            tilt_y,
        )
    # Center pantilt
    pantiltGoHome()
    logging.info("End")

    if not os.path.isfile(PANO_PROG_PATH):
        logging.error("Cannot Find Pano Executable File at %s", PANO_PROG_PATH)
        logging.info("Please run menubox.sh UPGRADE to correct problem")
        logging.warning("Exiting - Cannot Run Image Stitching of Images.")
        return
    if not os.path.isfile("./config.cfg"):
        logging.error("Cannot Find ./config.cfg required for %s", PANO_PROG_PATH)
        logging.info("Please run menubox.sh UPGRADE to correct problem")
        logging.warning("Exiting - Cannot Run Image Stitching of Images.")
        return
    # Create the stitch command line string
    stitch_cmd = PANO_PROG_PATH + " " + pano_file_path + pano_image_files
    try:
        logging.info("Run Image Stitching Command per Below")
        print("%s" % stitch_cmd)
        # spawn stitch command with parameters as seperate task
        proc = subprocess.Popen(
            stitch_cmd, shell=True, stdin=None, stdout=None, stderr=None, close_fds=True
        )
    except IOError:
        logging.error("Failed subprocess %s", stitch_cmd)
    pano_seq_num += 1
    if PANO_NUM_RECYCLE and PANO_NUM_MAX > 0:
        if pano_seq_num >= PANO_NUM_START + PANO_NUM_MAX:
            logging.info(
                "PANO_NUM_RECYCLE Activated. Reset pano_seq_num to %i", PANO_NUM_START
            )
            pano_seq_num = PANO_NUM_START
    writeCounter(pano_seq_num, NUM_PATH_PANO)
    return pano_seq_num


# ------------------------------------------------------------------------------
def videoRepeat():
    """
    This is a special dash cam video mode
    that overrides both timelapse and motion tracking settings
    It has it's own set of settings to manage start, video duration,
    number recycle mode, Etc.
    """
    # Check if folder exist and create if required
    if not os.path.isdir(VIDEO_DIR):
        logging.info("Create videoRepeat Folder %s", VIDEO_DIR)
        os.makedirs(VIDEO_DIR)
    print("--------------------------------------------------------------------")
    print("VideoRepeat . VIDEO_REPEAT_ON=%s" % VIDEO_REPEAT_ON)
    print(
        "   Info ..... Size=%ix%i  VIDEO_PREFIX=%s  VIDEO_FILE_SEC=%i seconds  VIDEO_FPS=%i"
        % (
            VIDEO_REPEAT_WIDTH,
            VIDEO_REPEAT_HEIGHT,
            VIDEO_PREFIX,
            VIDEO_FILE_SEC,
            VIDEO_FPS,
        )
    )
    print("   Vid Path . VIDEO_DIR= %s" % VIDEO_DIR)
    print(
        "   Sched .... VIDEO_START_AT=%s blank=Off or Set Valid Date and/or Time to Start Sequence"
        % VIDEO_START_AT
    )
    print(
        "   Timer .... VIDEO_SESSION_MIN=%i minutes  0=Continuous" % VIDEO_SESSION_MIN
    )
    print(
        "   Num Seq .. VIDEO_NUM_ON=%s  VIDEO_NUM_RECYCLE_ON=%s  VIDEO_NUM_START=%i"
        "  VIDEO_NUM_MAX=%i 0=Continuous"
        % (VIDEO_NUM_ON, VIDEO_NUM_RECYCLE_ON, VIDEO_NUM_START, VIDEO_NUM_MAX)
    )
    print("--------------------------------------------------------------------")
    print(
        "WARNING: VIDEO_REPEAT_ON=%s Suppresses TimeLapse and Motion Settings."
        % VIDEO_REPEAT_ON
    )
    startVideoRepeat = getSchedStart(VIDEO_START_AT)
    if not checkSchedStart(startVideoRepeat):
        logging.info('VIDEO_START_AT = "%s" ', VIDEO_START_AT)
        logging.info(
            "Video Repeat: Sched Start Set For %s  Please Wait ...", startVideoRepeat
        )
        while not checkSchedStart(startVideoRepeat):
            pass
    videoStartTime = datetime.datetime.now()
    lastSpaceCheck = datetime.datetime.now()
    videoCount = 0
    videoNumCounter = VIDEO_NUM_START
    keepRecording = True
    while keepRecording:
        # if required check free disk space and delete older files
        # Set variables SPACE_TARGET_EXT='mp4' and
        # SPACE_MEDIA_DIR= to appropriate folder path
        if SPACE_TIMER_HOURS > 0:
            lastSpaceCheck = freeDiskSpaceCheck(lastSpaceCheck)
        filename = getVideoName(VIDEO_DIR, VIDEO_PREFIX, VIDEO_NUM_ON, videoNumCounter)
        takeVideo(
            filename, VIDEO_FILE_SEC, VIDEO_REPEAT_WIDTH, VIDEO_REPEAT_HEIGHT, VIDEO_FPS
        )
        timeUsed = (datetime.datetime.now() - videoStartTime).total_seconds()
        timeRemaining = (VIDEO_SESSION_MIN * 60 - timeUsed) / 60.0
        videoCount += 1
        if VIDEO_NUM_ON:
            videoNumCounter += 1
            if VIDEO_NUM_MAX > 0:
                if videoNumCounter - VIDEO_NUM_START > VIDEO_NUM_MAX:
                    if VIDEO_NUM_RECYCLE_ON:
                        videoNumCounter = VIDEO_NUM_START
                        logging.info(
                            "Restart Numbering: VIDEO_NUM_RECYCLE_ON=%s "
                            "and VIDEO_NUM_MAX=%i Exceeded",
                            VIDEO_NUM_RECYCLE_ON,
                            VIDEO_NUM_MAX,
                        )
                    else:
                        keepRecording = False
                        logging.info(
                            "Exit since VIDEO_NUM_RECYCLE_ON=%s "
                            "and VIDEO_NUM_MAX=%i Exceeded  %i Videos Recorded",
                            VIDEO_NUM_RECYCLE_ON,
                            VIDEO_NUM_MAX,
                            videoCount,
                        )
                logging.info("Recorded %i of %i Videos", videoCount, VIDEO_NUM_MAX)
            else:
                logging.info(
                    "Recorded %i Videos  VIDEO_NUM_MAX=%i 0=Continuous",
                    videoCount,
                    VIDEO_NUM_MAX,
                )
        else:
            logging.info(
                "Progress: %i Videos Recorded in Folder %s", videoCount, VIDEO_DIR
            )
        if VIDEO_SESSION_MIN > 0:
            if timeUsed > VIDEO_SESSION_MIN * 60:
                keepRecording = False
                errorText = (
                    "Stop Recording Since VIDEO_SESSION_MIN=%i minutes Exceeded \n",
                    VIDEO_SESSION_MIN,
                )
                logging.warning(errorText)
                sys.stdout.write(errorText)
            else:
                logging.info(
                    "Remaining Time %.1f of %i minutes",
                    timeRemaining,
                    VIDEO_SESSION_MIN,
                )
        else:
            videoStartTime = datetime.datetime.now()
    logging.info("Exit: %i Videos Recorded in Folder %s", videoCount, VIDEO_DIR)


# ------------------------------------------------------------------------------
def timolo():
    """
    Main motion and or motion tracking
    initialization and logic loop
    """
    # Counter for showDots() display if not motion found
    # shows system is working

    cam_tl_pos = 0  # PANTILT_SEQ_STOPS List Start position of pantilt
    pan_x, tilt_y = PANTILT_SEQ_STOPS[cam_tl_pos]
    dotCount = 0
    checkMediaPaths()
    timelapseNumCount = 0
    motionNumCount = 0

    tlstr = ""  # Used to display if timelapse is selected
    mostr = ""  # Used to display if motion is selected
    moCnt = "non"
    tlCnt = "non"

    daymode = False  # Keep track of night and day based on dayPixAve

    motionFound = False
    take_timelapse = True
    stop_timelapse = False
    takeMotion = True
    stopMotion = False

    # Initialize some Timers
    pix_ave_timer = datetime.datetime.now()
    pantilt_seq_timer = datetime.datetime.now()
    motion_force_timer = datetime.datetime.now()
    timelapseExitStart = datetime.datetime.now()
    startTL = getSchedStart(TIMELAPSE_START_AT)
    startMO = getSchedStart(MOTION_START_AT)
    trackLen = 0.0
    if SPACE_TIMER_HOURS > 0:
        lastSpaceCheck = datetime.datetime.now()
    if TIMELAPSE_ON:
        tlstr = "TimeLapse"
        # Check if timelapse subDirs reqd and create one if non exists
        tlPath = subDirChecks(
            TIMELAPSE_SUBDIR_MAX_HOURS,
            TIMELAPSE_SUBDIR_MAX_FILES,
            TIMELAPSE_DIR,
            TIMELAPSE_PREFIX,
        )
        if TIMELAPSE_NUM_ON:
            timelapseNumCount = getCurrentCount(NUM_PATH_TIMELAPSE, TIMELAPSE_NUM_START)
            tlCnt = str(timelapseNumCount)
    else:
        logging.warning("Timelapse is Suppressed per TIMELAPSE_ON=%s", TIMELAPSE_ON)
        stop_timelapse = True
    if MOTION_TRACK_ON:
        logging.info("Start PiVideoStream ....")
        vs = PiVideoStream().start()
        vs.camera.rotation = IMAGE_ROTATION
        vs.camera.hflip = IMAGE_HFLIP
        vs.camera.vflip = IMAGE_VFLIP
        time.sleep(2)
        mostr = "Motion Tracking"
        # Check if motion subDirs required and
        # create one if required and non exists
        moPath = subDirChecks(
            MOTION_SUBDIR_MAX_HOURS, MOTION_SUBDIR_MAX_FILES, MOTION_DIR, MOTION_PREFIX
        )
        if MOTION_NUM_ON:
            motionNumCount = getCurrentCount(NUM_PATH_MOTION, MOTION_NUM_START)
            moCnt = str(motionNumCount)
        trackTimeout = time.time()
        trackTimer = TRACK_TIMEOUT
        startPos = []
        startTrack = False
        image1 = vs.read()
        image2 = vs.read()
        pixAve = getStreamPixAve(image2)
        grayimage1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
        daymode = checkIfDayStream(daymode, image2)
    else:
        vs = PiVideoStream().start()
        time.sleep(0.5)
        image2 = vs.read()  # use video stream to check for pixAve & daymode
        pixAve = getStreamPixAve(image2)
        daymode = checkIfDayStream(daymode, image2)
        vs.stop()
        logging.info(
            "Motion Tracking is Suppressed per variable MOTION_TRACK_ON=%s",
            MOTION_TRACK_ON,
        )
        stopMotion = True
    if TIMELAPSE_ON and MOTION_TRACK_ON:
        tlstr = " and " + tlstr
    displayInfo(moCnt, tlCnt)  # Display config.py settings

    if LOG_TO_FILE_ON:
        logging.info("LOG_TO_FILE_ON=%s Logging to Console Disabled.", LOG_TO_FILE_ON)
        logging.info("Sending Console Messages to %s", LOG_FILE_PATH)
        logging.info("Entering Loop for %s%s", mostr, tlstr)
    else:
        if PLUGIN_ON:
            logging.info("plugin %s - Start %s%s Loop ...", PLUGIN_NAME, mostr, tlstr)
        else:
            logging.info("Start %s%s Loop ... ctrl-c Exits", mostr, tlstr)
    if MOTION_TRACK_ON and not checkSchedStart(startMO):
        logging.info('Motion Track: MOTION_START_AT = "%s"', MOTION_START_AT)
        logging.info("Motion Track: Sched Start Set For %s  Please Wait ...", startMO)
    if TIMELAPSE_ON and not checkSchedStart(startTL):
        logging.info('Timelapse   : TIMELAPSE_START_AT = "%s"', TIMELAPSE_START_AT)
        logging.info("Timelapee   : Sched Start Set For %s  Please Wait ...", startTL)
    logging.info("daymode=%s  MOTION_DOTS_ON=%s ", daymode, MOTION_DOTS_ON)
    dotCount = showDots(MOTION_DOTS_MAX)  # reset motion dots
    # Check to make sure PANTILT_ON is enabled if required.
    if PANTILT_SEQ_ON and not PANTILT_ON:
        logging.warning(
            "PANTILT_SEQ_ON=True but PANTILT_ON=False (Suggest you Enable PANTILT_ON=True)"
        )
    if PANO_ON and not PANTILT_ON:
        logging.warning(
            "PANO_ON=True but PANTILT_ON=False (Suggest you Enable PANTILT_ON=True)"
        )
    if (MOTION_TRACK_PANTILT_SEQ_ON and MOTION_TRACK_ON) and not PANTILT_ON:
        logging.warning(
            "MOTION_TRACK_PANTILT_SEQ_ON=True but PANTILT_ON=False (Suggest you Enable PANTILT_ON=True)"
        )
    first_pano = True  # Force a pano sequence on startup
    firstTimeLapse = True  # Force a timelapse on startup
    while True:  # Start main program Loop.
        motionFound = False
        if (
            MOTION_TRACK_ON
            and (not MOTION_NUM_RECYCLE_ON)
            and (motionNumCount > MOTION_NUM_START + MOTION_NUM_MAX)
            and (not stopMotion)
        ):
            logging.warning(
                "MOTION_NUM_RECYCLE_ON=%s and motionNumCount %i Exceeds %i",
                MOTION_NUM_RECYCLE_ON,
                motionNumCount,
                MOTION_NUM_START + MOTION_NUM_MAX,
            )
            logging.warning("Suppressing Further Motion Tracking")
            logging.warning(
                "To Reset: Change %s Settings or Archive Images", CONFIG_FILENAME
            )
            logging.warning(
                "Then Delete %s and Restart %s \n", NUM_PATH_MOTION, PROG_NAME
            )
            takeMotion = False
            stopMotion = True
        if (
            stop_timelapse
            and stopMotion
            and not PANTILT_SEQ_ON
            and not PANO_ON
            and not VIDEO_REPEAT_ON
        ):
            logging.warning(
                "NOTICE: Motion, Timelapse, pantilt_seq, Pano and Video Repeat are Disabled"
            )
            logging.warning(
                "per Num Recycle=False and "
                "Max Counter Reached or TIMELAPSE_EXIT_SEC Settings"
            )
            logging.warning(
                "Change %s Settings or Archive/Save Media Then", CONFIG_FILENAME
            )
            logging.warning("Delete appropriate .dat File(s) to Reset Counter(s)")
            logging.warning("Exiting pi-timolo \n")
            sys.exit(1)
        # if required check free disk space and delete older files (jpg)
        if SPACE_TIMER_HOURS > 0:
            lastSpaceCheck = freeDiskSpaceCheck(lastSpaceCheck)
        # check the timer for measuring pixel average of stream image frame
        pix_ave_timer, take_pix_ave = checkTimer(pix_ave_timer, IMAGE_PIX_AVE_TIMER_SEC)
        # use image2 to check daymode as image1 may be average
        # that changes slowly, and image1 may not be updated
        if take_pix_ave:
            pixAve = getStreamPixAve(image2)
            daymode = checkIfDayStream(daymode, image2)
            if daymode != checkIfDayStream(daymode, image2):
                daymode = not daymode
        if MOTION_TRACK_ON:
            if daymode != checkIfDayStream(daymode, image2):
                daymode = not daymode
                image2 = vs.read()
                image1 = image2
            else:
                image2 = vs.read()
        elif TIMELAPSE_ON:
            vs = PiVideoStream().start()
            time.sleep(0.5)
            image2 = vs.read()  # use video stream to check for daymode
            vs.stop()

        if not daymode and TIMELAPSE_ON:
            time.sleep(0.02)  # short delay to aviod high cpu usage at night
        # Don't take images if IMAGE_NO_NIGHT_SHOTS
        # or IMAGE_NO_DAY_SHOTS settings are True
        if not timeToSleep(daymode):
            # Check if it is time for pantilt sequence
            if PANTILT_ON and PANTILT_SEQ_ON:
                pantilt_seq_timer, take_pantilt_sequence = checkTimer(
                    pantilt_seq_timer, PANTILT_SEQ_TIMER_SEC
                )
                if take_pantilt_sequence:
                    if MOTION_TRACK_ON:
                        vs.stop()
                        time.sleep(STREAM_STOP_SEC)
                    seq_prefix = PANTILT_SEQ_IMAGE_PREFIX + IMAGE_NAME_PREFIX
                    seq_num_count = getCurrentCount(
                        NUM_PATH_PANTILT_SEQ, PANTILT_SEQ_NUM_START
                    )
                    filename = getImageFilename(
                        PANTILT_SEQ_IMAGES_DIR,
                        seq_prefix,
                        PANTILT_SEQ_NUM_ON,
                        seq_num_count,
                    )
                    seq_num_count = takePantiltSequence(
                        filename, daymode, pixAve, seq_num_count, NUM_PATH_PANTILT_SEQ
                    )
                    if MOTION_TRACK_ON:
                        vs = PiVideoStream().start()
                        vs.camera.rotation = IMAGE_ROTATION
                        vs.camera.hflip = IMAGE_HFLIP
                        vs.camera.vflip = IMAGE_VFLIP
                        time.sleep(1)  # Allow camera to warm up and stream to start
                    next_seq_time = pantilt_seq_timer + datetime.timedelta(
                        seconds=PANTILT_SEQ_TIMER_SEC
                    )
                    next_seq_at = "%02d:%02d:%02d" % (
                        next_seq_time.hour,
                        next_seq_time.minute,
                        next_seq_time.second,
                    )
                    logging.info(
                        "Next Pantilt Sequence in %i seconds at %s  Waiting ...",
                        PANTILT_SEQ_TIMER_SEC,
                        next_seq_at,
                    )
            # Process Timelapse events per timers
            if TIMELAPSE_ON and checkSchedStart(startTL):
                # Check for a scheduled date/time to start timelapse
                if firstTimeLapse:
                    timelapse_timer = datetime.datetime.now()
                    firstTimeLapse = False
                    take_timelapse = True
                else:
                    timelapse_timer, take_timelapse = checkTimer(
                        timelapse_timer, TIMELAPSE_TIMER_SEC
                    )
                if (not stop_timelapse) and take_timelapse and TIMELAPSE_EXIT_SEC > 0:
                    if (
                        datetime.datetime.now() - timelapseExitStart
                    ).total_seconds() > TIMELAPSE_EXIT_SEC:
                        logging.info(
                            "TIMELAPSE_EXIT_SEC=%i Exceeded.", TIMELAPSE_EXIT_SEC
                        )
                        logging.info("Suppressing Further Timelapse Images")
                        logging.info(
                            "To RESET: Restart %s to Restart "
                            "TIMELAPSE_EXIT_SEC Timer. \n",
                            PROG_NAME,
                        )
                        # Suppress further timelapse images
                        take_timelapse = False
                        stop_timelapse = True
                if (
                    (not stop_timelapse)
                    and TIMELAPSE_NUM_ON
                    and (not TIMELAPSE_NUM_RECYCLE_ON)
                ):
                    if TIMELAPSE_NUM_MAX > 0 and timelapseNumCount > (
                        TIMELAPSE_NUM_START + TIMELAPSE_NUM_MAX
                    ):
                        logging.warning(
                            "TIMELAPSE_NUM_RECYCLE_ON=%s and Counter=%i Exceeds %i",
                            TIMELAPSE_NUM_RECYCLE_ON,
                            timelapseNumCount,
                            TIMELAPSE_NUM_START + TIMELAPSE_NUM_MAX,
                        )
                        logging.warning("Suppressing Further Timelapse Images")
                        logging.warning(
                            "To RESET: Change %s Settings or Archive Images",
                            CONFIG_FILENAME,
                        )
                        logging.warning(
                            "Then Delete %s and Restart %s \n",
                            NUM_PATH_TIMELAPSE,
                            PROG_NAME,
                        )
                        # Suppress further timelapse images
                        take_timelapse = False
                        stop_timelapse = True
                if take_timelapse and (not stop_timelapse):
                    # Reset the timelapse timer
                    if MOTION_DOTS_ON and MOTION_TRACK_ON:
                        # reset motion dots
                        dotCount = showDots(MOTION_DOTS_MAX + 2)
                    else:
                        print("")
                    if PLUGIN_ON:
                        if TIMELAPSE_EXIT_SEC > 0:
                            exitSecProgress = (
                                datetime.datetime.now() - timelapseExitStart
                            ).total_seconds()
                            logging.info(
                                "%s Sched TimeLapse  daymode=%s  Timer=%i sec"
                                "  ExitSec=%i/%i Status",
                                PLUGIN_NAME,
                                daymode,
                                TIMELAPSE_TIMER_SEC,
                                exitSecProgress,
                                TIMELAPSE_EXIT_SEC,
                            )
                        else:
                            logging.info(
                                "%s Sched TimeLapse  daymode=%s"
                                "  Timer=%i sec  ExitSec=%i 0=Continuous",
                                PLUGIN_NAME,
                                daymode,
                                TIMELAPSE_TIMER_SEC,
                                TIMELAPSE_EXIT_SEC,
                            )
                    else:
                        if TIMELAPSE_EXIT_SEC > 0:
                            exitSecProgress = (
                                datetime.datetime.now() - timelapseExitStart
                            ).total_seconds()
                            logging.info(
                                "Sched TimeLapse  daymode=%s  Timer=%i sec"
                                "  ExitSec=%i/%i Status",
                                daymode,
                                TIMELAPSE_TIMER_SEC,
                                exitSecProgress,
                                TIMELAPSE_EXIT_SEC,
                            )
                        else:
                            logging.info(
                                "Sched TimeLapse  daymode=%s  Timer=%i sec"
                                "  ExitSec=%i 0=Continuous",
                                daymode,
                                TIMELAPSE_TIMER_SEC,
                                TIMELAPSE_EXIT_SEC,
                            )
                    tl_prefix = TIMELAPSE_PREFIX + IMAGE_NAME_PREFIX
                    filename = getImageFilename(
                        tlPath, tl_prefix, TIMELAPSE_NUM_ON, timelapseNumCount
                    )

                    if MOTION_TRACK_ON:
                        logging.info("Stop Motion Tracking PiVideoStream ...")
                        vs.stop()
                        time.sleep(STREAM_STOP_SEC)
                    # Time to take a Day or Night Time Lapse Image

                    if daymode:
                        takeDayImage(filename, TIMELAPSE_CAM_SLEEP_SEC)
                    else:
                        takeNightImage(filename, pixAve)
                    timelapseNumCount = postImageProcessing(
                        TIMELAPSE_NUM_ON,
                        TIMELAPSE_NUM_START,
                        TIMELAPSE_NUM_MAX,
                        timelapseNumCount,
                        TIMELAPSE_NUM_RECYCLE_ON,
                        NUM_PATH_TIMELAPSE,
                        filename,
                        daymode,
                    )
                    saveRecent(
                        TIMELAPSE_RECENT_MAX, TIMELAPSE_RECENT_DIR, filename, tl_prefix
                    )

                    if MOTION_TRACK_ON:
                        logging.info("Restart Motion Tracking PiVideoStream ....")
                        vs = PiVideoStream().start()
                        vs.camera.rotation = IMAGE_ROTATION
                        vs.camera.hflip = IMAGE_HFLIP
                        vs.camera.vflip = IMAGE_VFLIP
                        time.sleep(1)  # Allow camera to warm up and stream to start
                    if TIMELAPSE_MAX_FILES > 0:
                        deleteOldFiles(TIMELAPSE_MAX_FILES, TIMELAPSE_DIR, tl_prefix)
                    dotCount = showDots(MOTION_DOTS_MAX)

                    tlPath = subDirChecks(
                        TIMELAPSE_SUBDIR_MAX_HOURS,
                        TIMELAPSE_SUBDIR_MAX_FILES,
                        TIMELAPSE_DIR,
                        TIMELAPSE_PREFIX,
                    )
                    next_timelapse_time = timelapse_timer + datetime.timedelta(
                        seconds=TIMELAPSE_TIMER_SEC
                    )
                    next_timelapse_at = "%02d:%02d:%02d" % (
                        next_timelapse_time.hour,
                        next_timelapse_time.minute,
                        next_timelapse_time.second,
                    )
                    logging.info("Next Timelapse at %s  Waiting ...", next_timelapse_at)
                    pantiltGoHome()
            # Monitor for motion tracking events
            # and trigger selected action eg image, quick pic, video, mini TL, pantilt
            if (
                MOTION_TRACK_ON
                and checkSchedStart(startMO)
                and takeMotion
                and (not stopMotion)
            ):
                # IMPORTANT - Night motion tracking may not work very well
                #             due to long exposure times and low light
                image2 = vs.read()
                grayimage2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
                movePoint1 = getMotionTrackPoint(grayimage1, grayimage2)
                grayimage1 = grayimage2
                if movePoint1 and not startTrack:
                    startTrack = True
                    trackTimeout = time.time()
                    startPos = movePoint1
                image2 = vs.read()
                grayimage2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
                movePoint2 = getMotionTrackPoint(grayimage1, grayimage2)
                if movePoint2 and startTrack:  # Two sets of movement required
                    trackLen = trackMotionDistance(startPos, movePoint2)
                    # wait until track well started
                    if trackLen > TRACK_TRIG_LEN_MIN:
                        # Reset tracking timer object moved
                        trackTimeout = time.time()
                        if MOTION_TRACK_INFO_ON:
                            logging.info(
                                "Track Progress From(%i,%i) To(%i,%i) trackLen=%i/%i px",
                                startPos[0],
                                startPos[1],
                                movePoint2[0],
                                movePoint2[1],
                                trackLen,
                                TRACK_TRIG_LEN,
                            )
                    # Track length triggered
                    if trackLen >= TRACK_TRIG_LEN:
                        # reduce chance of two objects at different positions
                        if trackLen >= TRACK_TRIG_LEN_MAX:
                            motionFound = False
                            if MOTION_TRACK_INFO_ON:
                                logging.info(
                                    "TrackLen %i px Exceeded %i px Max Trig Len Allowed.",
                                    trackLen,
                                    TRACK_TRIG_LEN_MAX,
                                )
                        else:
                            motionFound = True
                            if PLUGIN_ON:
                                logging.info(
                                    "%s Motion Triggered Start(%i,%i)"
                                    "  End(%i,%i) trackLen=%.i/%i px",
                                    PLUGIN_NAME,
                                    startPos[0],
                                    startPos[1],
                                    movePoint2[0],
                                    movePoint2[1],
                                    trackLen,
                                    TRACK_TRIG_LEN,
                                )
                            else:
                                logging.info(
                                    "Motion Triggered Start(%i,%i)"
                                    "  End(%i,%i) trackLen=%i/%i px",
                                    startPos[0],
                                    startPos[1],
                                    movePoint2[0],
                                    movePoint2[1],
                                    trackLen,
                                    TRACK_TRIG_LEN,
                                )
                            print("")
                        image1 = vs.read()
                        image2 = image1
                        grayimage1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
                        grayimage2 = grayimage1
                        startTrack = False
                        startPos = []
                        trackLen = 0.0
                # Track timed out
                if (time.time() - trackTimeout > trackTimer) and startTrack:
                    image1 = vs.read()
                    image2 = image1
                    grayimage1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
                    grayimage2 = grayimage1
                    if MOTION_TRACK_ON and MOTION_TRACK_INFO_ON:
                        logging.info(
                            "Track Timer %.2f sec Exceeded. Reset Track", trackTimer
                        )
                    startTrack = False
                    startPos = []
                    trackLen = 0.0
                if MOTION_FORCE_SEC > 0:
                    motion_force_timer, motion_force_start = checkTimer(
                        motion_force_timer, MOTION_FORCE_SEC
                    )
                else:
                    motion_force_start = False
                if motion_force_start:
                    image1 = vs.read()
                    image2 = image1
                    grayimage1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
                    grayimage2 = grayimage1
                    dotCount = showDots(MOTION_DOTS_MAX + 2)  # New Line
                    logging.info(
                        "No Motion Detected for %s minutes. "
                        "Taking Forced Motion Image.",
                        (MOTION_FORCE_SEC / 60),
                    )
                if motionFound or motion_force_start:
                    motion_prefix = MOTION_PREFIX + IMAGE_NAME_PREFIX
                    filename = getImageFilename(
                        moPath, motion_prefix, MOTION_NUM_ON, motionNumCount
                    )
                    vs.stop()
                    time.sleep(STREAM_STOP_SEC)

                    # Save stream image frame to capture movement quickly
                    if MOTION_TRACK_QUICK_PIC_ON:
                        takeMotionQuickImage(image2, filename)
                        motionNumCount = postImageProcessing(
                            MOTION_NUM_ON,
                            MOTION_NUM_START,
                            MOTION_NUM_MAX,
                            motionNumCount,
                            MOTION_NUM_RECYCLE_ON,
                            NUM_PATH_MOTION,
                            filename,
                            daymode,
                        )
                        saveRecent(
                            MOTION_RECENT_MAX,
                            MOTION_RECENT_DIR,
                            filename,
                            motion_prefix,
                        )
                    # Save a series of images per settings (no pantilt)
                    elif MOTION_TRACK_MINI_TL_ON and daymode:
                        with picamera.PiCamera() as camera:
                            camera.resolution = (image_width, image_height)
                            camera.vflip = IMAGE_VFLIP
                            camera.hflip = IMAGE_HFLIP
                            # valid rotation values 0, 90, 180, 270
                            camera.rotation = IMAGE_ROTATION
                            time.sleep(MOTION_CAM_SLEEP)
                            # This uses yield to loop through time lapse
                            # sequence but does not seem to be faster
                            # due to writing images
                            camera.capture_sequence(
                                takeMiniTimelapse(
                                    moPath,
                                    motion_prefix,
                                    MOTION_NUM_ON,
                                    motionNumCount,
                                    daymode,
                                    NUM_PATH_MOTION,
                                )
                            )
                            camera.close()
                            motionNumCount = getCurrentCount(
                                NUM_PATH_MOTION, MOTION_NUM_START
                            )
                    # Move camera pantilt through specified positions and take images
                    elif MOTION_TRACK_ON and PANTILT_ON and MOTION_TRACK_PANTILT_SEQ_ON:
                        motionNumCount = takePantiltSequence(
                            filename, daymode, pixAve, motionNumCount, NUM_PATH_MOTION
                        )
                        pantiltGoHome()
                    elif MOTION_VIDEO_ON:
                        filename = getVideoName(
                            MOTION_PATH, motion_prefix, MOTION_NUM_ON, motionNumCount
                        )
                        takeVideo(
                            filename,
                            MOTION_VIDEO_TIMER_SEC,
                            MOTION_VIDEO_WIDTH,
                            MOTION_VIDEO_HEIGHT,
                            MOTION_VIDEO_FPS,
                        )
                        if MOTION_NUM_ON:
                            motionNumCount += 1
                            writeCounter(motionNumCount, NUM_PATH_MOTION)
                    else:
                        if daymode:
                            takeDayImage(filename, MOTION_CAM_SLEEP)
                        else:
                            takeNightImage(filename, pixAve)
                        motionNumCount = postImageProcessing(
                            MOTION_NUM_ON,
                            MOTION_NUM_START,
                            MOTION_NUM_MAX,
                            motionNumCount,
                            MOTION_NUM_RECYCLE_ON,
                            NUM_PATH_MOTION,
                            filename,
                            daymode,
                        )

                        saveRecent(
                            MOTION_RECENT_MAX,
                            MOTION_RECENT_DIR,
                            filename,
                            motion_prefix,
                        )
                    vs = PiVideoStream().start()
                    vs.camera.rotation = IMAGE_ROTATION
                    vs.camera.hflip = IMAGE_HFLIP
                    vs.camera.vflip = IMAGE_VFLIP
                    time.sleep(1)
                    image1 = vs.read()
                    image2 = image1
                    grayimage1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
                    grayimage2 = grayimage1
                    trackLen = 0.0
                    trackTimeout = time.time()
                    startPos = []
                    startTrack = False
                    moPath = subDirChecks(
                        MOTION_SUBDIR_MAX_HOURS,
                        MOTION_SUBDIR_MAX_FILES,
                        MOTION_DIR,
                        MOTION_PREFIX,
                    )
                    logging.info("Waiting for Next Motion Tracking Event ...")
            # Take panoramic images and stitch together if possible per settings
            if PANTILT_ON and PANO_ON:
                # force a pano on first startup then go by timer.
                if first_pano:
                    first_pano = False
                    start_pano = True
                    pano_seq_num = getCurrentCount(NUM_PATH_PANO, PANO_NUM_START)
                    pano_timer = datetime.datetime.now()
                else:
                    # Check if pano timer expired and if so start a pano sequence
                    pano_timer, start_pano = checkTimer(pano_timer, PANO_TIMER_SEC)
                if start_pano:
                    if MOTION_TRACK_ON:
                        logging.info("Stop Motion Tracking PiVideoStream ...")
                        vs.stop()
                        time.sleep(STREAM_STOP_SEC)
                    pano_seq_num = takePano(pano_seq_num, daymode, pixAve)
                    if MOTION_TRACK_ON:
                        logging.info("Restart Motion Tracking PiVideoStream ....")
                        vs = PiVideoStream().start()
                        vs.camera.rotation = IMAGE_ROTATION
                        vs.camera.hflip = IMAGE_HFLIP
                        vs.camera.vflip = IMAGE_VFLIP
                        time.sleep(1)
                    next_pano_time = pano_timer + datetime.timedelta(
                        seconds=PANO_TIMER_SEC
                    )
                    next_pano_at = "%02d:%02d:%02d" % (
                        next_pano_time.hour,
                        next_pano_time.minute,
                        next_pano_time.second,
                    )
                    logging.info("Next Pano at %s  Waiting ...", next_pano_at)

            if motionFound and motionCode:
                # ===========================================
                # Put your user code in userMotionCode() function
                # In the File user_motion_code.py
                # ===========================================
                try:
                    user_motion_code.userMotionCode(filename)
                    dotCount = showDots(MOTION_DOTS_MAX)
                except ValueError:
                    logging.error(
                        "Problem running userMotionCode function from File %s",
                        userMotionFilePath,
                    )
            else:
                # show progress dots when no motion found
                dotCount = showDots(dotCount)


# ------------------------------------------------------------------------------
if __name__ == "__main__":
    """
    Initialization prior to launching
    appropriate pi-timolo options
    """
    logging.info("Testing if Pi Camera is in Use")
    # Test if the pi camera is already in use
    ts = PiVideoStream().start()
    time.sleep(1)
    ts.stop()
    time.sleep(STREAM_STOP_SEC)
    logging.info("Pi Camera is Available.")
    if PANTILT_ON:
        logging.info("Camera Pantilt Hardware is %s", pantilt_is)
    if PLUGIN_ON:
        logging.info(
            "Start pi-timolo per %s and plugins/%s.py Settings",
            CONFIG_FILE_PATH,
            PLUGIN_NAME,
        )
    else:
        logging.info("Start pi-timolo per %s Settings", CONFIG_FILE_PATH)
    if not VERBOSE_ON:
        print("NOTICE: Logging Disabled per variable VERBOSE_ON=False  ctrl-c Exits")
    try:
        pantiltGoHome()
        if VIDEO_REPEAT_ON:
            videoRepeat()
        else:
            timolo()
    except KeyboardInterrupt:
        print("")
        pantiltGoHome()  # Ensure mouse is returned to home position
        if VERBOSE_ON:
            logging.info("User Pressed Keyboard ctrl-c")
            logging.info(f"Exiting {PROG_NAME}")
        else:
            sys.stdout.write("User Pressed Keyboard ctrl-c \n")
            sys.stdout.write(f"Exiting {PROG_NAME}\n")
    try:
        if PLUGIN_ON:
            if os.path.isfile(pluginCurrent):
                os.remove(pluginCurrent)
            pluginCurrentpyc = os.path.join(pluginDir, "current.pyc")
            if os.path.isfile(pluginCurrentpyc):
                os.remove(pluginCurrentpyc)
    except OSError as err:
        logging.warning("Failed To Remove File %s - %s", pluginCurrentpyc, err)
        sys.exit(1)