Office Clock using RaspberryPi

<?php

    $file_path = "/var/www/settings.json";

    //error message for API pages
    function send_error($message){
        http_response_code(403);
        echo $message;
        die();
    }

    //function for settings changes
    function change_settings($param, $value){
        global $file_path;
        
        //object which stores the desired settings
        $content = (object)[];

        //loading the already existent settings to be overwritten by the new changes
        if(file_exists($file_path))
            $content = json_decode(file_get_contents($file_path));

        //changing if the value exists, and if it doesn't, the property gets deleted
        if($value == "")
            unset($content->$param);
        else
            $content->$param = $value;

        //writing the values back into the file
        file_put_contents($file_path, json_encode($content));

        //alternative and inefficient - instant execution of the routine function to modify the shown values on the screen
        // exec("sudo python3 /home/pi/watch/routine.py 2>&1", $output);
        // print_r($output);

        //creating a new empty file to let the main process know that there were changes to the configuration file
        file_put_contents("/var/www/UPDATE_DATA", "");

        //exiting php script
        die();
    }

    $type = null;

    //checking if the typed location exists and return the API page status
    function check_weather($loc){
        @file_get_contents("http://wttr.in/" . urlencode($loc) . "?format=%t", false, stream_context_create(["http" => ["ignore_errors" => true]]));

        //checking http header and returning the page status
        if(!empty($http_response_header) && count($http_response_header) > 1){
            $parts = explode(" ", $http_response_header[0]);
            return (int)$parts[1];
        }
        else{
            //returning 404 error if the API cannot be reached
            return 404;
        }
    }

    //choosing the setting type
    //syncronization setting, just storing the boolean option
    if(isset($_POST["sincronizare"]))
        $type = "sincronizare";
    //location setting, checking if the requested location exists
    else if(isset($_POST["locatie"])){
        $check = check_weather($_POST["locatie"]);

        if($check == 200)
            $type = "locatie";
        else
            send_error("Eroare: locatia selectata nu exista");
    }
    //custom time setting, checking if the requested time is correct and also storing a system timestamp - chosen timestamp pair, for difference calculus
    else if(isset($_POST["ora"]) && strpos($_POST["ora"], ";") !== false){
        $parts = explode(";", $_POST["ora"]);
        $parts[0] = $parts[0] == "" ? 0 : $parts[0];
        $parts[1] = $parts[1] == "" ? 0 : $parts[1];
        $custom = strtotime(date("j F Y") . " " . $parts[0] . ":" . $parts[1]);

        if($custom === false || (int)$parts[0] < 0 || (int)$parts[1] < 0)
            send_error("Eroare: timpul selectat este unul incorect");

        change_settings("ora", time() . ";" . $custom);
    }

    //changing the settings by type, one at a time
    if($type != null)
        change_settings($type, $_POST[$type]);

    //getting the existing settings to be shown on the webpage
    if(file_exists($file_path)){
        //reading the file
        $settings = json_decode(file_get_contents($file_path));

        //getting the simple settings
        if(isset($settings->sincronizare))
            $sync = $settings->sincronizare;
        if(isset($settings->locatie))
            $location = $settings->locatie;
        
        //calculating the custom time, the sum of the current system timestamp and the difference between the two values stored as a pair
        if(isset($settings->ora) && strpos($settings->ora, ";") !== false){
            $diff = time() - (int)(explode(";", $settings->ora)[0]);
            $custom = (int)(explode(";", $settings->ora)[1]) + $diff;
            $custom = explode(";", date("G;i", $custom));
            $hours = $custom[0];
            $minutes = $custom[1];
        }
    }

    //checking the time sync checkbox
    $sincronizare = isset($sync) && $sync == "true";

?>
<!DOCTYPE html>
<html>
    <head>
        <title>Office clock - SM Project</title>
        <meta charset="utf-8"/>
        <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Montserrat"/>
        <link rel="stylesheet" href="index.css"/>
    </head>
    <body>
        <div class="main">
            <h1>Office clock - SM Project</h1>
            <div>
                <span>Sync clock with the internet:</span>
                <label class="ceas_internet">
                    <input type="checkbox" name="ceas_internet" <?= $sincronizare ? "checked" : "" ?>>
                    <div class="check"></div>
                </label>
            </div>
            <div class="set <?= $sincronizare ? "disabled" : "" ?>">
                <span>Set the time:</span>
                <input type="number" name="ceas_ora" placeholder="H" value="<?= isset($hours) ? htmlspecialchars($hours) : "" ?>">
                <input type="number" name="ceas_minut" placeholder="M" value="<?= isset($minutes) ? htmlspecialchars($minutes) : "" ?>">
            </div>
            <div>
                <span>Weather location:</span>
                <input type="text" name="ceas_locatie" placeholder="Current location by IP" value="<?= isset($location) ? htmlspecialchars($location) : "" ?>">
            </div>
        </div>
        <script src="index.js"></script>
    </body>
</html>

import os
import json
import requests
import urllib
import time
import Adafruit_DHT
import RPi.GPIO as GPIO

#CONFIG_PATH = os.path.dirname(os.path.realpath(__file__)) + "/settings.json"
CONFIG_PATH = "/var/www/settings.json"
DHT11BCM = 18 #DHT11 DATA GPIO TYPE PIN
DHT11BOARD = 12 #DHT11 DATA BOARD TYPE PIN

#internet request function
def request(url):
    try:
        response = requests.get(url, timeout=2)
    except:
        return False

    #logging
    print("Cerere la " + url + " cu raspunsul " + str(response.status_code))

    if response.status_code >= 200 and response.status_code < 300:
        #return the response if the request is successful
        return response.text
    else:
        #returning False if something wrong happened
        return False

def find_weather(location):
    #request to wttr.in to get informations about chosen location
    res = request("http://wttr.in/" + urllib.parse.quote(location, safe='') + "?format=%t")

    if res is False or len(res) > 10:
        #if the request was unsuccessful
        return ""
    else:
        #parsing the number before the special character
        return res.split('°')[0]

def get_temperature():
    #reading temperature data from the DHT11, 5 retries, 0.5 delay between retries
    h, temperature = Adafruit_DHT.read_retry(Adafruit_DHT.DHT11, DHT11BCM, 5, 0.5)

    #logging
    print("Temperatura citita de la senzor " + str(temperature))

    #returning temperature if the reading was correct
    if temperature is not None:
        return str(int(temperature))
    else:
        return ""

def get_time():
    #reading the time from the ntp server
    res = request("http://worldtimeapi.org/api/ip")
    #storing the system timestamp
    unix = time.time()

    if res is not False:
        #server response - json parsing
        content = json.loads(res)
        
        if "unixtime" in content:
            unix = int(float(content["unixtime"]))

    #sending the system timestamp - ntp server response pair, to get the offset between the two
    return str(int(time.time())) + "=" + str(unix)


def main():
    clock = ""
    weather = ""
    temperature = ""

    #init pins for DHT11
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(DHT11BOARD, GPIO.IN)

    #getting the interior temperature
    temperature = get_temperature()

    #if configuration exists, displaying with the current settings
    if os.path.exists(CONFIG_PATH):
        #reading config
        config = open(CONFIG_PATH, "r", encoding="utf-8")
        config = json.loads(config.read())
        
        #if the weather location is specified
        if "locatie" in config:
            weather = find_weather(config["locatie"])
        else:
            weather = find_weather("")

        #if the internet sync is on or a custom time is specified
        if "sincronizare" not in config or ("sincronizare" in config and config["sincronizare"] == "true"):
            clock = get_time()
        elif "ora" in config and config["ora"].find(";") != -1:
            parts = config["ora"].split(';')
            #sending the system - custom time pair
            clock = parts[0] + "=" + parts[1]
    #if configuration doesn't exist, display with default settings
    else:
        weather = find_weather("")
        clock = get_time()

    #sending data to environment variable for main thread processing
    os.environ["WATCH_ROUTINE_DATA"] = clock + ";" + weather + ";" + temperature

    #logging
    print(os.environ["WATCH_ROUTINE_DATA"])


main()

import RPi.GPIO as GPIO
from time import sleep

LINES = 16

class LEDMatrix:

    #matrix rotation, changing the screen orientation from vertical to horizontal
    def rotate_matrix(self, m):
        return [m[j * LINES + i] for i in range(LINES - 1, -1, -1) for j in range(LINES)]

    def Delay(self, timp):
        #sleep(timp / 100000000.0) # 1 timp = ~ 10 ns - alternative option with longer delay, requested from the OS

        #NOP for n number of cycles
        n = 4
        i = 0
        while i < timp * n:
            i += 1

    def __LineSelect(self, line):
        #selecting the current line for the LED matrix, transforming from decimal to binary
        if line >= LINES:
            return

        b = [0] * 4

        for i in range(0, 4):
            b[i] = line >> i
            b[i] = b[i] & 0x1

        GPIO.output(self.__D, b[3])
        GPIO.output(self.__C, b[2])
        GPIO.output(self.__B, b[1])
        GPIO.output(self.__A, b[0])


    def Draw(self, array):
        #from vertical to horizontal
        array = self.rotate_matrix(array)

        #G signal turns the whole screen off, we don't want this
        GPIO.output(self.__G, 0)

        for line in range(0, LINES):
            #setting the signals on low
            GPIO.output(self.__LAT, 0) #latch
            GPIO.output(self.__CLK, 0) #clock
            
            self.__LineSelect(line)

            for column in range(LINES - 1, -1, -1):
                self.Delay(1)

                #sending the current bit on the led
                GPIO.output(self.__DI, array[line * LINES + column])

                #clock signal
                self.Delay(1)
                GPIO.output(self.__CLK, 1)

                self.Delay(1)
                GPIO.output(self.__CLK, 0)

            #latch signal
            GPIO.output(self.__LAT, 1)
            self.Delay(1)


    def __init__(self, D, C, B, A, G, DI, CLK, LAT):
        self.__D = D
        self.__C = C
        self.__B = B
        self.__A = A
        self.__G = G
        self.__DI = DI
        self.__CLK = CLK
        self.__LAT = LAT

        #pins configuration
        GPIO.setmode(GPIO.BOARD)

        GPIO.setup(D, GPIO.OUT)
        GPIO.setup(C, GPIO.OUT)
        GPIO.setup(B, GPIO.OUT)
        GPIO.setup(A, GPIO.OUT)
        GPIO.setup(G, GPIO.OUT)
        GPIO.setup(DI, GPIO.OUT)
        GPIO.setup(CLK, GPIO.OUT)
        GPIO.setup(LAT, GPIO.OUT)

import os
import screen

BIG_DIMENSIONS = {"width": 8, "height": 7}
SMALL_DIMENSIONS = {"width": 3, "height": 5}

big_characters = {}
small_characters = {}

TYPE_BIG = 1
TYPE_SMALL = 2

#reading the character from file on init
def get_matrix(path, dimensions):
    filename = os.path.dirname(os.path.abspath(__file__)) + path
    array = [1] * (dimensions["width"] * dimensions["height"])
    arrayIndex = 0
    
    if os.path.exists(filename):
        file = open(filename, "r", encoding="utf-8")
        lines = file.read().split('\n')

        #reading each line
        for i in range(0, len(lines)):
            columns = lines[i].split(' ')

            #reading every value on the line
            for j in range(0, len(columns)):
                if columns[j] != "":
                    #int to string casting, and if it is impossible, turn the led off
                    try:
                        array[arrayIndex] = int(columns[j])
                    except:
                        array[arrayIndex] = 1

                    #moving to the next stored bit
                    arrayIndex += 1

                #returning from the function if the values count is bigger than the char dimension
                if arrayIndex >= (dimensions["width"] * dimensions["height"]):
                    break

            if arrayIndex >= (dimensions["width"] * dimensions["height"]):
                break

    return array

def place_character_intern(parent, character, dimensions, position):
    index = 0
    #replacing the lines with the character values
    for i in range(position["top"], position["top"] + dimensions["height"]):
        for j in range(position["left"], position["left"] + dimensions["width"]):
            parent[i * screen.LINES + j] = character[index]
            index += 1

    return parent

#function to place the char on the given position by type - BIG / SMALL
def place_character(parent, character, type, position):
    dimensions = BIG_DIMENSIONS
    array = big_characters

    if type == TYPE_SMALL:
        dimensions = SMALL_DIMENSIONS
        array = small_characters
    elif type == TYPE_BIG:
        pass
    else:
        return

    return place_character_intern(parent, array[character], dimensions, position)

#module initialization
def init():
    #storing the numbers
    for i in range(0, 10):
        big_characters[i] = get_matrix("/big_numbers/" + str(i), BIG_DIMENSIONS)
        small_characters[i] = get_matrix("/small_numbers/" + str(i), SMALL_DIMENSIONS)

    # and the special characters
    small_characters["o"] = get_matrix("/small_numbers/o", SMALL_DIMENSIONS)
    small_characters["i"] = get_matrix("/small_numbers/i", SMALL_DIMENSIONS)
    small_characters["-"] = get_matrix("/small_numbers/dash", SMALL_DIMENSIONS)

init()