233 lines
7.8 KiB
Python
Executable File
233 lines
7.8 KiB
Python
Executable File
# bin/python3
|
|
# encoding: utf-8
|
|
|
|
import os
|
|
import sys
|
|
import time
|
|
import signal
|
|
import requests
|
|
import logging
|
|
import subprocess
|
|
|
|
# Configuration
|
|
LOG_FILE = "/tmp/daemon.log"
|
|
IMG_URL = "http://10.0.1.113:56733/image"
|
|
IMAGE_PATH = "/mnt/us/extensions/ascwebdash/data/received_image.png"
|
|
PID_FILE = "/tmp/mydaemon.pid"
|
|
REFRESH_SECONDS=1800
|
|
|
|
# Configure logging
|
|
logging.basicConfig(
|
|
filename=LOG_FILE,
|
|
level=logging.INFO,
|
|
format="%(asctime)s [%(levelname)s] %(message)s",
|
|
datefmt="%Y-%m-%d %H:%M:%S",
|
|
)
|
|
|
|
def fetch_image_from_server(url, save_path):
|
|
"""Fetch a IMG file from an HTTP server."""
|
|
logging.info(f"Fetching IMG from {url}")
|
|
try:
|
|
response = requests.get(url, stream=True)
|
|
response.raise_for_status() # Raise HTTP errors
|
|
with open(save_path, "wb") as image_file:
|
|
for chunk in response.iter_content(1024):
|
|
image_file.write(chunk)
|
|
logging.info(f"Image saved to {save_path}")
|
|
return True
|
|
except Exception as e:
|
|
logging.error(f"Failed to fetch IMG: {e}")
|
|
return False
|
|
|
|
def display_image_with_fbink(image_path):
|
|
"""Display the IMG image on the Kindle using FBInk."""
|
|
logging.info(f"Displaying image: {image_path}")
|
|
try:
|
|
os.system(f"fbink -i {image_path} > /dev/null 2>&1")
|
|
logging.info("Image displayed successfully.")
|
|
except Exception as e:
|
|
logging.error(f"Failed to display image: {e}")
|
|
|
|
def write_pid():
|
|
with open(PID_FILE, "w") as f:
|
|
f.write(str(os.getpid()))
|
|
|
|
def handle_signal(signum, frame):
|
|
"""Handle incoming signals."""
|
|
if signum == signal.SIGHUP:
|
|
logging.info("Received SIGHUP signal: Refreshing state...")
|
|
set_wifi(True)
|
|
logging.info("Fetching image")
|
|
display_image_with_fbink(IMAGE_PATH)
|
|
display_battery_percentage(get_battery_percentage())
|
|
set_wifi(False)
|
|
elif signum == signal.SIGTERM:
|
|
logging.info("Received SIGTERM signal: Exiting daemon...")
|
|
sys.exit(0)
|
|
|
|
def set_deep_sleep(enable: bool):
|
|
"""
|
|
Enable or disable deep sleep on the Kindle.
|
|
|
|
Args:
|
|
enable (bool): If True, enables deep sleep. If False, disables deep sleep.
|
|
"""
|
|
try:
|
|
# Map boolean argument to corresponding lipc-set-prop value
|
|
value = "0" if enable else "1"
|
|
subprocess.run(
|
|
["lipc-set-prop", "com.lab126.powerd", "preventScreenSaver", value],
|
|
check=True,
|
|
)
|
|
action = "enabled" if enable else "disabled"
|
|
logging.info(f"Deep sleep {action} successfully.")
|
|
logging.debug(f"Deep sleep {action} successfully.")
|
|
except subprocess.CalledProcessError as e:
|
|
action = "enable" if enable else "disable"
|
|
logging.error(f"Failed to {action} deep sleep: {e}")
|
|
logging.debug(f"Failed to {action} deep sleep: {e}")
|
|
|
|
def get_battery_percentage():
|
|
"""Retrieve the Kindle's battery percentage."""
|
|
try:
|
|
# Run the command to get battery percentage
|
|
result = subprocess.run(
|
|
["lipc-get-prop", "com.lab126.powerd", "battLevel"],
|
|
capture_output=True,
|
|
text=True,
|
|
check=True,
|
|
)
|
|
# Extract and return the percentage as an integer
|
|
return int(result.stdout.strip())
|
|
except Exception as e:
|
|
logging.debug(f"Error retrieving battery percentage: {e}")
|
|
return None
|
|
|
|
def display_battery_percentage(battery_percentage):
|
|
"""Display the battery percentage on the screen using FBInk."""
|
|
try:
|
|
# Construct the message
|
|
message = f"{battery_percentage}%"
|
|
|
|
# Display the message using FBInk
|
|
os.system(f"fbink -x 10 -p {message} > /dev/null 2>&1")
|
|
logging.debug("Battery percentage displayed successfully.")
|
|
except Exception as e:
|
|
logging.debug(f"Error displaying battery percentage: {e}")
|
|
|
|
def send_sighup():
|
|
"""Send SIGHUP signal to the daemon."""
|
|
if not os.path.exists(PID_FILE):
|
|
logging.debug("Daemon is not running (PID file not found).")
|
|
return
|
|
|
|
try:
|
|
# Read the PID from the file
|
|
with open(PID_FILE, "r") as f:
|
|
pid = int(f.read().strip())
|
|
|
|
# Send the SIGHUP signal
|
|
os.kill(pid, signal.SIGHUP)
|
|
logging.debug("SIGHUP signal sent to the daemon.")
|
|
except Exception as e:
|
|
logging.debug(f"Failed to send SIGHUP: {e}")
|
|
|
|
|
|
def set_gui(enable: bool):
|
|
"""
|
|
Start or stop the Kindle GUI based on the enable input.
|
|
|
|
Args:
|
|
enable (bool): If True, starts the GUI. If False, stops the GUI.
|
|
"""
|
|
action = "start" if enable else "stop"
|
|
try:
|
|
subprocess.run([action, "lab126_gui"], check=True)
|
|
logging.info(f"GUI {action}ped successfully.")
|
|
except subprocess.CalledProcessError as e:
|
|
logging.info(f"Failed to {action} GUI: {e}")
|
|
|
|
def set_wifi(enable: bool):
|
|
"""
|
|
Toggle Wi-Fi on or off based on the `enable` boolean input.
|
|
|
|
Args:
|
|
enable (bool): If True, Wi-Fi will be turned on. If False, Wi-Fi will be turned off.
|
|
"""
|
|
try:
|
|
if enable:
|
|
# Enable Wi-Fi
|
|
# logging.info("Starting Wi-Fi...")
|
|
# subprocess.run(["lipc-set-prop", "com.lab126.cmd", "wirelessEnable", "1"], check=True)
|
|
# time.sleep(60)
|
|
# logging.info("Wi-Fi has been enabled.")
|
|
pass
|
|
else:
|
|
# Disable Wi-Fi
|
|
# subprocess.run(["lipc-set-prop", "com.lab126.cmd", "wirelessEnable", "0"], check=True)
|
|
# logging.info("Wi-Fi has been disabled.")
|
|
pass
|
|
except subprocess.CalledProcessError as e:
|
|
logging.error(f"Failed to toggle Wi-Fi: {e}")
|
|
|
|
def main():
|
|
"""Main daemon process."""
|
|
logging.info("Daemon started")
|
|
while True:
|
|
if fetch_image_from_server(IMG_URL, IMAGE_PATH):
|
|
set_wifi(True)
|
|
logging.info("Fetching image")
|
|
display_image_with_fbink(IMAGE_PATH)
|
|
display_battery_percentage(get_battery_percentage())
|
|
set_wifi(False)
|
|
else:
|
|
logging.error("Could not fetch or display image.")
|
|
time.sleep(REFRESH_SECONDS) # Sleep before fetching again
|
|
|
|
|
|
if __name__ == "__main__":
|
|
# Handle termination signals
|
|
signal.signal(signal.SIGTERM, handle_signal)
|
|
signal.signal(signal.SIGINT, handle_signal)
|
|
signal.signal(signal.SIGHUP, handle_signal)
|
|
|
|
# Process command-line arguments
|
|
if len(sys.argv) > 1:
|
|
if sys.argv[1] == "start":
|
|
# Write PID file and start the daemon
|
|
write_pid()
|
|
set_deep_sleep(False)
|
|
set_gui(False)
|
|
main()
|
|
elif sys.argv[1] == "stop":
|
|
# Stop the daemon
|
|
if os.path.exists(PID_FILE):
|
|
with open(PID_FILE, "r") as f:
|
|
pid = int(f.read())
|
|
os.kill(pid, signal.SIGTERM)
|
|
os.remove(PID_FILE)
|
|
set_deep_sleep(True)
|
|
set_gui(True)
|
|
logging.debug("Daemon stopped.")
|
|
else:
|
|
logging.debug("PID file not found. Is the daemon running?")
|
|
elif sys.argv[1] == "refresh":
|
|
if os.path.exists(PID_FILE):
|
|
send_sighup()
|
|
else:
|
|
logging.debug("PID file not found. Is the daemon running?")
|
|
elif sys.argv[1] == "restart":
|
|
# Restart the daemon
|
|
if os.path.exists(PID_FILE):
|
|
with open(PID_FILE, "r") as f:
|
|
pid = int(f.read())
|
|
os.kill(pid, signal.SIGTERM)
|
|
os.remove(PID_FILE)
|
|
logging.debug("Daemon stopped.")
|
|
# Start the daemon
|
|
write_pid()
|
|
main()
|
|
else:
|
|
logging.debug("Invalid command. Use 'start', 'stop', or 'restart'.")
|
|
else:
|
|
logging.debug("Usage: python3 mydaemon.py [start|stop|restart]") |