Das deutsche Python-Forum

Code: Alles auswählen

In [289]: round(0.015, 2)                                                       
Out[289]: 0.01

In [290]: round(0.025, 2)                                                       
Out[290]: 0.03

In [291]: round(0.035, 2)                                                       
Out[291]: 0.04

Code: Alles auswählen

#!/usr/bin/env python3
import datetime
import ftplib
import os
import shutil
import struct
from datetime import date
from pathlib import Path

import thingspeak

FTP_HOSTNAME = "192.168.1.44"
FTP_USERNAME = "XXX"
FTP_PASSWORD = "XXX"

CHANNEL_ID = "XXX"
WRITE_KEY = "XXX"
READ_KEY = "XXX"

DATASET_COUNT = 18
ADDITIONAL_HEADER_SIZE = 18
DATASET_HEADER_SIZE = 6

TIMESTAMP_STRUCT = struct.Struct(">I")
INFO_STRUCT = struct.Struct(">f")

DATASET_INFO_SIZE = INFO_STRUCT.size


def main():
    today = date.today()

    year_path = Path(f"{today:%Y}")
    for month in range(1, 13):
        (year_path / f"{month:02d}").mkdir(parents=True, exist_ok=True)

    month_path = year_path / f"{today:%m}"

    print("Open temp file for writing")
    temporary_file_path = month_path / "temp.log"
    with temporary_file_path.open("w+b") as temporary_file:
        try:
            print("Open connection to FTP Server")
            try:
                ftp = ftplib.FTP(
                    FTP_HOSTNAME, FTP_USERNAME, FTP_PASSWORD, timeout=10
                )
            except ftplib.all_errors:
                print("FTP Server not reachable aborting connection")
            else:
                with ftp:
                    ftp.set_pasv(False)
                    ftp.cwd(f"/data/logger/{today:%Y}/{today:%m}")
                    print("Get file from FTP")
                    ftp.retrbinary(
                        f"RETR {today:%d}.log", temporary_file.write
                    )
                    print("Closing FTP connection")

                # Determine the file length of the received file
                print("Move to the end of the received file to get length")
                temporary_file.seek(0, os.SEEK_END)
                temporary_file_size = temporary_file.tell()
                print("Length of temporary file", temporary_file_size)

            print("Move to the start of received file")
            temporary_file.seek(0)

            local_file_path = month_path / f"{today:%d}.log"
            print("Filename for the local file:", local_file_path.name)
            print("Trying to open local logfile")
            with local_file_path.open("w+b") as local_file:
                print("Move to end to get filesize")
                local_file.seek(0, os.SEEK_END)
                local_filesize = local_file.tell()
                print("Length of local file:", local_filesize)
                local_file.seek(0)

                if temporary_file_size > local_filesize:
                    print("More data in received file than in local file")
                    print("Transfer data from received file to local file")
                    print("Transfer data from received file to old logfile")
                    shutil.copyfileobj(temporary_file, local_file)
                    #
                    # Move to the start of the last entry.
                    #
                    # Offset consisting of 18 datasets with 10 byte each + 12
                    # byte 0xFF + 4 byte Unix time + 2 bytes length information.
                    #
                    local_file.seek(
                        -DATASET_COUNT
                        * (DATASET_HEADER_SIZE + INFO_STRUCT.size)
                        + ADDITIONAL_HEADER_SIZE,
                        os.SEEK_END,
                    )
                    timestamp = datetime.datetime.fromtimestamp(
                        TIMESTAMP_STRUCT.unpack(
                            local_file.read(TIMESTAMP_STRUCT.size)
                        )[0]
                    )
                    print(f"{timestamp:%Y-%m-%d %H:%M:%S}")

                    _ = local_file.read(14)

                    values = list()
                    for _ in range(DATASET_COUNT):
                        _ = local_file.read(DATASET_HEADER_SIZE)
                        values.append(
                            INFO_STRUCT.unpack(
                                local_file.read(INFO_STRUCT.size)
                            )[0]
                        )
                        print(f"{values[-1]:.2f}")
                    #
                    # TODO Consider use of `round()`.
                    #
                    dc_powers = [round(values[i], 2) for i in range(3)]
                    total_dc_power = round(sum(dc_powers), 2)
                    water_temperature = round(values[4], 2)
                    internal_temperature = round(values[5], 2)
                    total_kwh = round((values[12] / 10), 2)
                    kwh_day = round(
                        sum(round(values[13 + i] / 10, 2) for i in range(3)), 2
                    )

                    print("DC Power total:", total_dc_power)
                    print("Water Temperature", water_temperature)
                    print("Total kWh", total_kwh)
                    #
                    # TODO Really „Actual“?  Or maybe „Current“, or simply
                    #   „Today's“.
                    #
                    print("Actual Day kWh:", kwh_day)
                    print("Internal Temperature:", internal_temperature)
                    for i, dc_power in enumerate(dc_powers, 1):
                        print(f"DC Power {i}: {dc_power}")

                    print("Sending data to thingspeak")
                    channel = thingspeak.Channel(
                        CHANNEL_ID, WRITE_KEY, READ_KEY
                    )
                    try:
                        channel.update(
                            {
                                f"field{i}": value
                                for i, value in enumerate(
                                    [
                                        total_dc_power,
                                        water_temperature,
                                        total_kwh,
                                        kwh_day,
                                        internal_temperature,
                                        *dc_powers,
                                    ],
                                    1,
                                )
                            }
                        )
                        print("Sending of data completed")
                    except:
                        print("connection failed")
                else:
                    print("No new data available")

                print("Reading of datablocks from local file complete")
                print("Closing both local and temporary file")
        finally:
            print("Deleting temporary file")
            temporary_file_path.unlink()

    print("Python script complete")


if __name__ == "__main__":
    main()

Code: Alles auswählen

python3 -m pip install thingspeak