On my raspberryPi Pico-w I have a program that gets weather data from open-meteo and displays a selection on the lcd1602.

Due to the limited space I want to show the wind by an arrow.
Hence special characters.
Or instead of wind-arrows, I would like to show the degree-sign instead of a hyphen.

At the moment I use it as class extension: class ExtendedHD44780(HD44780)
It is not my knowledge, I just scraped snippets from here and there 😉

For fun: the program I use to auto start on the pico:

Example micropython program for the Raspberry Pi Pico-w

# ###################### the begin #############################################
# pylint: disable = E0401  # Unable to import 'urequests' (import-error)
# pylint: disable = E0611
# pylint: disable = C0116  # Missing function or method docstring
# pylint: disable = C0114  # Missing module docstring (missing-module-docstring)
# pylint: disable = E0401
# pylint: disable = E1101
# pylint: disable = E0211

# TODO swap sleep for blink a led to wait.
# TODO iterate SSID if no connection.
import time
from secrets import secrets

import machine
from setup_wifi_general import setup

import urequests
from machine import I2C, Pin

from pcf8574 import PCF8574
from lcd import LCD
from hd44780 import HD44780
from format_localtime import formatLocaltime
from getnow import getNow

DO_REQUEST = True  # For debug, use False, we us our own string as input
DEBUG = not DO_REQUEST

led = machine.Pin("LED", machine.Pin.OUT)

DEGREE_SIGN = bytearray([0x06, 0x09, 0x09, 0x06, 0x00, 0x00, 0x00, 0x00])

FILE = "/log/autostart_log.txt"


def blink_one_second(_times=10, _wait=0.1):  # blinks the internal led on the RaspberryPi Pico-w
    """ By default blink 1 second """
    # led = machine.Pin("LED", machine.Pin.OUT)  # pico-w internal led

    for __ in range(_times):
        if led.value() == 1:
            led.off()
        else:
            led.on()
        time.sleep(_wait)
    led.off()


def log_to_file(log_time, text, file_path=FILE, print_line=True):
    """Append text to a file."""
    if __NAME__ != "lcd_openmeteo_forecast.py":
        formatted_time = formatLocaltime(log_time)
        with open(file_path, "a", encoding="utf8") as file:
            log_line = str(formatted_time) + "  " + text + "\n"
            file.write(log_line)
        if print_line:
            # the log_line already has a newline, so do not print an extra newline.
            print(log_line, end="")


def print_logfile(file_path=FILE):
    """Print the contents of a file."""
    if __NAME__ != "lcd_openmeteo_forecast.py":
        try:
            with open(file_path, "r", encoding="utf8") as file:
                contents = file.read()
                print(contents)
        except OSError as e:
            print("Error:", e)

# use lcd1602 to display n hours weather forcast

# # pylint: disable = E0401  # Unable to import 'urequests' (import-error)
# # pylint: disable = E0611
# # pylint: disable = C0116  # Missing function or method docstring


# weather codes: WMO Weather interpretation codes (WW)
WW_EN = {
    0: 'Clear sky',
    1: 'Mainly clear',
    2: 'Partly cloudy',
    3: 'Overcast',
    45: 'Fog',
    48: 'Depositing rime fog',
    51: 'Light Drizzle',
    53: 'Moderate Drizzle',
    55: 'Dense intensity Drizzle',
    56: 'Light Freezing Drizzle',
    57: 'Dense intensity Freezing Drizzle',
    61: 'Slight Rain',
    63: 'Moderate Rain',
    65: 'Heavy intensity Rain',
    66: 'Light Freezing Rain',
    67: 'Heavy intensity Freezing Rain',
    71: 'Slight Snow fall',
    73: 'Moderate Snow fall',
    75: 'Heavy intensity Snow fall',
    77: 'Snow grains',
    80: 'Slight Rain showers',
    81: 'Moderate Rain showers',
    82: 'Violent Rain showers',
    85: 'Slight Snow showers',
    86: 'Heavy Snow showers',
    95: 'Slight or moderate Thunderstorm',
    96: 'Thunderstorm with slight hail',
    99: 'Thunderstorm with heavy hail'
}
# Dutch translations
WW_NL = {
    0: 'Helder',
    1: 'Voornamelijk helder',
    2: 'Gedeeltelijk bewolkt',
    3: 'Bewolkt',
    45: 'Mist',
    48: 'Aanvriezende mist',
    51: 'Lichte motregen',
    53: 'Matige motregen',
    55: 'Dichte motregen',
    56: 'Lichte aanvriezende motregen',
    57: 'Dichte aanvriezende motregen',
    61: 'Lichte regen',
    63: 'Matige regen',
    65: 'Zware regen',
    66: 'Lichte ijzel',
    67: 'Zware ijzel',
    71: 'Lichte sneeuw',
    73: 'Matige sneeuw',
    75: 'Zware sneeuwval',
    77: 'Sneeuwkorrels',
    80: 'Lichte regenbuien',
    81: 'Matige regenbuien',
    82: 'Hevige regenbuien',
    85: 'Lichte sneeuwbuien',
    86: 'Zware sneeuwbuien',
    95: 'Lichte of matige onweersbui',
    96: 'Onweersbui met lichte hagel',
    99: 'Onweersbui met zware hagel'
}

# Danish translations
WW_DK = {
    0: 'Klar himmel',
    1: 'Hovedsagelig klar',
    2: 'Delvis skyet',
    3: 'Overskyet',
    45: 'Tåge',
    48: 'Aflejrende rimtåge',
    51: 'Let støvregn',
    53: 'Moderat støvregn',
    55: 'Tæt støvregn',
    56: 'Let frysende støvregn',
    57: 'Tæt frysende støvregn',
    61: 'Let regn',
    63: 'Moderat regn',
    65: 'Kraftig regn',
    66: 'Let frysende regn',
    67: 'Kraftig frysende regn',
    71: 'Let snefald',
    73: 'Moderat snefald',
    75: 'Kraftig snefald',
    77: 'Snefnug',
    80: 'Lette regnbyger',
    81: 'Moderate regnbyger',
    82: 'Voldsomme regnbyger',
    85: 'Lette snebyger',
    86: 'Kraftige snebyger',
    95: 'Let eller moderat tordenvejr',
    96: 'Tordenvejr med let hagl',
    99: 'Tordenvejr med kraftigt hagl'
}

WW = {'NL': WW_NL, 'DK': WW_DK, 'EN': WW_EN}

# Define custom characters for each wind direction
# (pointing to the direction where the wind comes from)
custom_arrows = [
    [0b00000, 0b00100, 0b00100, 0b00100, 0b10101, 0b01110, 0b00100, 0b00000],  # N  0
    [0b00000, 0b00001, 0b00010, 0b10100, 0b11000, 0b11100, 0b00000, 0b00000],  # NE 1
    [0b00000, 0b00100, 0b01000, 0b11111, 0b01000, 0b00100, 0b00000, 0b00000],  # E  2
    [0b11100, 0b11000, 0b10100, 0b00010, 0b00001, 0b00000, 0b00000, 0b00000],  # SE 3
    [0b00100, 0b01110, 0b10101, 0b00100, 0b00100, 0b00100, 0b00000, 0b00000],  # S  4
    [0b00111, 0b00011, 0b00101, 0b01000, 0b10000, 0b00000, 0b00000, 0b00000],  # SW 5
    [0b00000, 0b00100, 0b00010, 0b11111, 0b00010, 0b00100, 0b00000, 0b00000],  # W  6
    [0b00000, 0b10000, 0b01000, 0b00101, 0b00011, 0b00111, 0b00000, 0b00000],  # NW 7
]

WIND_ABBREV = ["N", "NE", "E", "SE", "S", "SW", "W", "NW"]

WIND_ABBREV_XLATE_NL_DK = {  # english into DUtch and Danish
    "N": ["N", "N"],
    "NE": ["NO", "NØ"],
    "E": ["O", "Ø"],
    "SE": ["ZO", "SØ"],
    "S": ["Z", "S"],
    "SW": ["ZW", "SV"],
    "W": ["W", "V"],
    "NW": ["NW", "NW"]
}

# Define the wind directions in degrees
wind_direction_degrees = {
    "N": set(range(338, 361)) | set(range(0, 23)),
    "NE": set(range(23, 68)),
    "E": set(range(68, 113)),
    "SE": set(range(113, 158)),
    "S": set(range(158, 203)),
    "SW": set(range(203, 248)),
    "W": set(range(248, 293)),
    "NW": set(range(293, 338))
}

map_wind2arrow = {"N": '0',
                  "NE": '1',
                  "E": '2',
                  "SE": '3',
                  "S": '4',
                  "SW": '5',
                  "W": '6',
                  "NW": '7',
                  }


class ExtendedHD44780(HD44780):  # pylint: disable=R0903 # Too few public methods (1/2) (too-few-public-methods)
    """extend the HD44780 class with the custom_char function"""

    # this import NEEDS to be here
    import utime  # pylint: disable=C0415  # Import outside toplevel

    def custom_char(self, location, charmap):
        # Write a character to one of the 8 CGRAM locations,
        # available as chr(0) through chr(7)
        # while the same characters are available as copies
        # at chr(8) through chr(15)
        location &= 0x7
        self._write_command(self.LCD_SET_CGRAM_ADDR | (location << 3))
        self.utime.sleep(0.00040)
        for _i in range(8):
            self._write_data(charmap[_i])
            self.utime.sleep(0.00040)
        # /BL dropped this.
        # /BL ?? self.set_cursor(self.cursor_x, self.cursor_y)


def setup_lcd1602():
    """ lcd 2 lines x 16 bytes """

    i2c = I2C(1, sda=Pin(6), scl=Pin(7), freq=400000)
    pcf8574 = PCF8574(i2c)
    _hd44780 = ExtendedHD44780(pcf8574, num_lines=2, num_columns=16)
    lcd_device = LCD(_hd44780, pcf8574)
    # Define custom characters for wind directions. e.g.:
    # _hd44780.custom_char(0, DEGREE_SIGN)

    # Load custom wind arrow characters into LCD
    for i1, char in enumerate(custom_arrows):
        if DEBUG:
            print(f'load arrow {i1}\t{char[0]:>08b} {WIND_ABBREV[i1]}')
            for i2 in range(1, len(char)):
                print(f'\t{char[i2]:>08b}')
            print(f"Write {i1} with {char}\n")
        _hd44780.custom_char(i1, char)
    lcd_device.display_on()
    return lcd_device, _hd44780


def lcd_off(lcd_unit):
    lcd_unit.backlight_off()
    lcd_unit.cursor_off()
    lcd_unit.blink_off()


def lcd_on(lcd_unit):
    lcd_unit.backlight_on()
    lcd_unit.cursor_off()
    lcd_unit.blink_off()


def setup_wifi():
    """ create network connection """
    SSID = secrets['ssid']          # pylint: disable=C0103
    WIFIPSWD = secrets['password']  # pylint: disable=C0103
    return setup(SSID, WIFIPSWD)


def get_forecast(req):
    """Get forecast and current
           of temperature and weather_code
    """
    print(f"get_forecast at UTC {time.localtime()} with req={req}\n")
    if DO_REQUEST:
        _weather = urequests.get(req).json()
    else:  # just use a string to test with.
        _weather = {'longitude': -0.1200001,
                    'hourly_units': {'time': 'iso8601',
                                     'temperature_2m': '\xb0C',
                                     'weather_code': 'wmo code'},
                    'timezone_abbreviation': 'BST',
                    'latitude': 51.5,
                    'generationtime_ms': 0.01704693,

                    'hourly': {'time': ['2024-05-08T20:00', '2024-05-08T21:00', '2024-05-08T22:00',
                                        '2024-05-08T23:00', '2024-05-09T00:00', '2024-05-09T01:00'],
                               'wind_direction_10m': [3, 43, 99, 141, 150, 160],
                               'wind_speed_10m': [9.5, 8.1, 7.6, 7.2, 5.9, 5.4],
                               'temperature_2m': [13.6, 12.4, 11.1, 10.2, 9.8, 9.4],
                               'weather_code': [2, 56, 61, 63, 65, 77]},
                    'elevation': 23.0,
                    'timezone': 'Europe/London',
                    'utc_offset_seconds': 3600}

    if DEBUG:
        print(f'Got _weather ALL:{type(_weather)}\n{_weather}')
        for item in _weather:
            print(f'\tweather[{item}]:\t{_weather[item]}"')
    return _weather


def format_weather(_weather):
    # current = _weather['current']
    # weather_dict = {'current': current, 'hourly': hourly}

    hourly = _weather['hourly']
    weather_dict = {'hourly': hourly}
    for key, value in weather_dict.items():
        print(f'\tweather_dict[{key}]: \t{value}')
    return weather_dict


# def decode_time(this_dict, item_name):
#     _cur = {}
#     if isinstance(this_dict[item_name]['time'], list):
#         _cur = [this_dict[item_name]['time'][_i][11:]
#                 for _i in range(len(this_dict[item_name]['time']))]
#     else:
#         _i = "cur"
#         _cur_i = this_dict[item_name]['time']
#         _cur[_i] = _cur_i[11:]
#     return _cur


def decode_key(this_dict, item_name, key, conversion_func=None):
    """
    Decode a specified key's value from each item in the dictionary.

    Args:
        this_dict (dict): The dictionary containing items.
        item_name (str): The name of the item in the dictionary.
        key (str): The key to decode from each item.
        conversion_func (function): Optional function to apply to each value.

    Returns:
        dict or list: A dictionary or list containing the decoded values.
    """
    # print(f'in decode_key START got key {key}', end=" ")
    # print(f'type {type(this_dict[item_name][key])}\n\t{this_dict[item_name][key]}')
    if key == 'time':
        if isinstance(this_dict[item_name][key], list):
            if conversion_func:
                return_value = [conversion_func(value) for value in this_dict[item_name][key]]
                # print(f'in decode_key 1 return type {type(return_value)}\n\t{return_value}')
                return return_value

            # print(f'in decode_key 2 return type {type(this_dict[item_name][key])}')
            # print(f'\t{this_dict[item_name][key]}')
            return this_dict[item_name][key]

        print(f'in decode_key 3 return type {type([this_dict[item_name][key]][11:])}')
        # print(f'\t{[this_dict[item_name][key]][11:]}')
        return [this_dict[item_name][key]][11:]

    decoded_values = {}
    if isinstance(this_dict[item_name][key], list):
        decoded_values = {}
        if isinstance(this_dict[item_name][key], list):
            if conversion_func:
                decoded_values = dict(zip(map(str, range(len(this_dict[item_name][key]))),
                                          map(conversion_func, this_dict[item_name][key])))
            else:
                decoded_values = dict(zip(map(str, range(len(this_dict[item_name][key]))),
this_dict[item_name][key]))
        else:
            decoded_values['cur'] = this_dict[item_name][key]

    else:
        decoded_values['cur'] = this_dict[item_name][key]

    # print(f'in decode_key 4 return type {type(decoded_values)}\n\t{decoded_values}')
    return decoded_values


def decode_weather_code(this_dict, item_name, location):
    code_text = {}
    code = this_dict[item_name]['weather_code']
    if not isinstance(code, list):
        code_text['cur'] = WW[location][code]
    else:
        code_text = {}
        code_text = [WW[location][_this_code] for _this_code in code]
    return code_text


def kmh_to_beaufort(wind_speed_kmh):
    beaufort_thresholds = [(1, 0), (6, 1), (12, 2), (20, 3), (29, 4), (39, 5),
                           (50, 6), (62, 7), (75, 8), (89, 9), (103, 10), (118, 11)]
    for speed, beaufort in beaufort_thresholds:
        if wind_speed_kmh < speed:
            return beaufort
    return 12


# Define a function to map degrees to wind direction indication
def map_wind_direction(degrees):
    for direction, degree_range in wind_direction_degrees.items():
        if degrees in degree_range:
            return direction
    return None


def wind_degree2dir(_dir):
    return map_wind_direction(_dir)


def datetime2time(_date):
    return _date[11:]


def decode_w_dir(this_dict, item_name):
    this_item = {}
    this_item = this_dict[item_name]['wind_direction_10m']
    # print(f'DEBUG decode_w_dir: this_item: {this_item}')
    if not isinstance(this_item, list):
        print(f'this_item is a list, not processed this_item: {this_item} ')
        this_item_dict = {"?": "????????"}
    else:
        this_item_dict = {str(_c): wind_degree2dir(this_item[_c]) for _c in range(len(this_item))}

    return this_item_dict


def translate_winddir(en_wind_abbrev, loc):
    en_wind_abbrev = en_wind_abbrev.strip()

    #    print(f'translate abbrev {en_wind_abbrev} to {loc}')
    #    print(WIND_ABBREV_XLATE_NL_DK)
    #    print(f'WIND_ABBREV_XLATE_NL_DK.get(en_wind_abbrev, en_wind_abbrev)
    #           {WIND_ABBREV_XLATE_NL_DK.get(en_wind_abbrev, en_wind_abbrev)}')
    #    print(f'WIND_ABBREV_XLATE_NL_DK[{en_wind_abbrev}]', end = "")
    #    print(f'{WIND_ABBREV_XLATE_NL_DK[en_wind_abbrev]}')

    _w = list(WIND_ABBREV_XLATE_NL_DK.get(en_wind_abbrev, en_wind_abbrev))
    # print(f'_w {type(_w)} len {len(_w)}  {_w}', end = " ")
    # print(f'return {_w[0]} or {_w[1]}')

    if loc == "NL":
        # print(f'_w {type(_w)} {_w} return {_w[0]}')
        return _w[0]

    if loc == "DK":
        # print(f'_w {type(_w)} {_w} return {_w[1]}')
        return _w[1]

    return en_wind_abbrev


def compose_screens(_time, _temp, _w_code, _w_speed, _w_dir):
    """ prepare the screens with fixed data for display """

    # forecast screens we like to show
    # line 0 0123456789012345
    #        xx                location (2 chars)
    #           xx:xx          Forecast time hh:mm
    #                 xx.x^C   temperature

    # line 1 0123456789012345
    #        xxxxxxxxxxxxxxxx weather code text (marquee if needed)
    #                        X add symbol Wind direction+speed to weather_code line

    # Main screen [0]:
    # line 0 0123456789012345
    #         xxxx-xx-xx      current date
    #           xx:xx:xx      current time
    # each screen is two lines of max 16 long with blank spaces where later variable data comes.

    scr_line = {}  # start empty

    localdatetime = getNow(UTC_OFFSET=LOCAL_TZ)

    formatteddatetime = formatLocaltime(localdatetime)
    _current_date = formatteddatetime[0]
    _current_time = formatteddatetime[1]

    # print(f'DEBUG working on {min(len(_time), len(_temp), len(_w_code))} periods')
    screens = {}
    screens['0'] = {'0': _current_date, '1': _current_time}
    for _i in range(min(len(_time), len(_temp), len(_w_code))):
        if DEBUG:
            print(f'DEBUG _time= "{_time}"')
            print(f'DEBUG _temp= "{_temp}"')
            print(f'\t{_i}\t set scr_line["0"] {_i} from ', end="")
            # int key
            print(f'\tGot time: {_time[_i]} ', end="")
            print(f'{_temp[str(_i)]}C')  # with No degree sign
            print(f'\t{_i}\tSet scr_line["0"] {_i} from {_time[_i]}')

        wind_arrow_int = int(map_wind2arrow[_w_dir[str(_i)]])
        scr_line['0'] = f'{LOC} {_time[_i]}{_temp[str(_i)]:>5.1f}C {chr(wind_arrow_int)}'
        p1 = f'{_w_code[_i]:<12}'
        p2_en = f'{_w_dir[str(_i)]:>2}'
        p2 = translate_winddir(p2_en, LOC)
        p3 = f'{_w_speed[str(_i)]}'
        # scr_line['1'] = f'{p1} {p2}{p3}'
        # print("native line:  '1234567890123456'")
        # print(f'native line:  "{scr_line['1']}"')
        scr_line['1'] = f'{p1} {" " * (15 - (len(p1) + len(p2) + len(p3)))}{p2}{p3}'
        if DEBUG:
            print(f'in compose_screens updated line: "{scr_line[str(1)]}"')

        screens[f'{str(_i + 1)}'] = {'0': scr_line['0'], '1': scr_line['1']}

    return screens


def write_text_at_pos_keep_rest(text, line, col, delay=0):
    # keeps the rest of the line as it was.
    hd44780.set_cursor(line, col)
    for char in text:
        hd44780.write_char(char)  # Cursor "auto-advances"
        if delay > 0:
            # time.sleep(delay)
            blink_one_second(delay * 10)


def split_long_sentence(line, max_length_per_line=16):
    """
    Split a long sentence into lines to fit a 16x2 LCD screen.

    Args:
        line (str): The long sentence to split.
        max_length_per_line (int): Maximum length per line on the LCD screen. Default is 16.

    Returns:
        list: A list of strings representing the lines.
        If there is room for it, the wind indication is pasted over the last 2 or 3 spaces
    """
    words = line.split()  # Split the line into words
    wind_indication = words[-1]  # Extract the wind indication
    words = words[:-1]  # Remove the wind indication from the words

    lines = []
    current_line = ""

    for word in words:
        if len(current_line) + len(word) + 1 > max_length_per_line:
            lines.append(current_line)
            current_line = ""
        if current_line:  # If line already started
            current_line += " " + word
        else:
            current_line = word

    if current_line:  # Add the last line if not empty
        lines.append(current_line)

    # Check if wind indication can fit on the right side of the line
    for i, _line in enumerate(lines):
        space_needed = len(_line) + 1 + len(wind_indication)
        if space_needed <= max_length_per_line:  # If there's space for the wind indication
            lines[i] = f'{_line}{" " * (max_length_per_line - space_needed)} {wind_indication}'

    return lines


def fetch_weather():
    log_to_file(time.localtime(), WAIT_TEXT)
    lcd.write_line(WAIT_TEXT, 0)
    lcd.write_line(f'=-> {PLACE:<12}', 1)

    # go ask open meteo for the forcast:
    weather = get_forecast(f'{URL1}{URL2}{URL3}{URL4}{URL5}{URL6}')

    lcd.scroll_content_off_screen("left", delay=0.25)  # shift text off the screen
    lcd.clear()  # neede here otherwise the lcd is useless.

    return weather


def setup_weather_screens(weather):

    weather_status = format_weather(weather)
    # print(f'wather_status = "{weather_status}"')

    # collect the data we like to show:
    w_code_dict = decode_weather_code(weather_status, "hourly", LOC)
    # time_dict_old = decode_time(weather_status, 'hourly')
    # print(f'dict of time_old  : {time_dict_old}')

    time_dict = decode_key(weather_status, 'hourly', 'time', datetime2time)
    # print(f'dict of time  : {time_dict}')

    temp_dict = decode_key(weather_status, 'hourly', 'temperature_2m')

    # wind_speed_kph = decode_w_speed(weather_status, "hourly")
    wind_speed = decode_key(weather_status, 'hourly', 'wind_speed_10m', kmh_to_beaufort)
    # wind_speed = decode_key(weather_status, 'hourly', 'wind_speed_10m')

    wind_dir = decode_w_dir(weather_status, "hourly")

    if DEBUG:
        print(f'dict of time  : {time_dict}')
        print(f'dict of temp  : {time_dict}')
        print(f'dict of code  : {w_code_dict}')
        print(f'dict of wspeed: {wind_speed}')
        print(f'dict of w_dir : {wind_dir}')

    # lcd_on(lcd)

    base_screens = compose_screens(time_dict, temp_dict, w_code_dict, wind_speed, wind_dir)

    # print(f'len(base_screens): {len(base_screens)}')
    # print(f'\tbase_screens["0"]: "0" {base_screens["1"]}')
    return base_screens


def display_weather(base_screens):
    # while True:
    # disply each screen
    # - current date and time on screen 0
    # - the requested forecasts after that
    # place wind indication on line 2 at the end if possible
    for i in range(len(base_screens)):
        try:
            # Get the current local time and update screen 0:
            if i == 0:  # screen with current date and time
                # mytime = time.localtime()
                mytime = getNow(LOCAL_TZ)
                # print(f"mytime: local {str(mytime)}")
                current_date = f' {mytime[0]:>4}-{mytime[1]:>02}-{mytime[2]:>02}'
                base_screens[str(i)] = {'0': current_date,
                                        '1': f' {mytime[3]:>2}:{mytime[4]:>02}:{mytime[5]:>02}'}

                lcd.write_line(base_screens[str(i)]['0'], 0)
                lcd.write_line(base_screens[str(i)]['1'], 1)
                # time.sleep(2.5)
                blink_one_second(2.5 * 10)
            else:  # forecast screens
write_text_at_pos_keep_rest(f"{base_screens[str(i)]['0']:<16}", 0, 0, 0)
                line2 = f"{base_screens[str(i)]['1']}"
                if len(line2) > 16:
                    line2_updated = split_long_sentence(line2)
                    # lcd.write_line(line2_updated, 1)

                    for line_part in line2_updated:
                        lcd.write_line(line_part, 1)
                        time.sleep(0.75)
                    time.sleep(0.5)
                else:
                    lcd.write_line(f"{line2:<16}", 1)
                    # time.sleep(1.5)
                    blink_one_second(15)  # 15 * 0.1 == 1.5 seconds

        except KeyboardInterrupt as exc:
            lcd_off(lcd)
            led.off()
            # use spaces instead of tabs for consistency
            spaces = " " * 28  # pylint: disable=C0103 # Constant name
            log_to_file(time.localtime(), f"UTC Program '{__NAME__}'\
                        \n{spaces}Keyboard interrupt - program ended")
            print_logfile()
            print()
            raise SystemExit(16) from exc


# mainline start:

blink_one_second()

LOCAL_TZ = 2
WEATHER_REFRESH_SECONDS = 15 * 60

__NAME__ = "auto_start.py"
log_text = f"UTC Program '{__NAME__}' started"
log_to_file(time.localtime(), log_text)

# setup wifi before trying to get the time via internet
log_to_file(time.localtime(), "setup wifi start")
setup_wifi()
log_to_file(time.localtime(), "setup wifi done")

log_date = getNow(UTC_OFFSET=LOCAL_TZ)
log_text = 'local time'  # pylint: disable=C0103 # Constant name
log_to_file(log_date, log_text)

PLACE1 = "Z. Holland"
LAT1 = '51.892625'
LON1 = '4.627072'
TZ1 = "auto"
HOURS1 = '8'
LOC1 = "NL"  # Short location
WAIT_TEXT1 = "Weer ophalen"

PLACE2 = "Kobnhavn"
LAT2 = '55.6761'  # Kobnhavn
LON2 = '12.5683'
TZ2 = "auto"
HOURS2 = '2'
LOC2 = "DK"

PLACE3 = "London"
LAT3 = '51.50853'
LON3 = '-0.12574'
TZ3 = 'auto'
HOURS3 = '4'
LOC3 = "EN"

PLACE4 = "SouthPole"
LAT4 = '-90'
LON4 = '0'
TZ4 = 'auto'
HOURS4 = '8'
LOC4 = "EN"

PLACE5 = "NorthPole"
LAT5 = '90'
LON5 = '0'
TZ5 = 'auto'
HOURS5 = '8'
LOC5 = "EN"

PLACE6 = "Perth"
LAT6 = '-31.9505'
LON6 = '115.8605'
TZ6 = 'auto'
HOURS6 = '8'
LOC6 = "EN"

# 1 = NL
# 2 = DK Kobenhavn
# 3 = London
# 4 = southpole
# 5 = northpole
# 6 = Perth
SETUP = 1

TZ = globals().get(f'TZ{SETUP}', None)
LAT = globals().get(f'LAT{SETUP}', None)
LON = globals().get(f'LON{SETUP}', None)
HOURS = globals().get(f'HOURS{SETUP}', "6")
LOC = globals().get(f'LOC{SETUP}', "EN")
PLACE = globals().get(f'PLACE{SETUP}', "?")
WAIT_TEXT = globals().get(f'WAIT_TEXT{SETUP}', "Get weather data")

# main line

settings_log = f"Start with settings for {PLACE}\n"
settings_log += " " * 28 + f"TZ     {TZ}\n"
settings_log += " " * 28 + f"LAT    {LAT}\n"
settings_log += " " * 28 + f"LON    {LON}\n"
settings_log += " " * 28 + f"LOC    {LOC}\n"
settings_log += " " * 28 + f"HOURS  {HOURS}"
log_to_file(time.localtime(), settings_log)
log_to_file(time.localtime(), "setup lcd")

lcd, hd44780 = setup_lcd1602()
lcd_on(lcd)

if DEBUG:
    for winddir in list(range(8)):   # [0, 1, 2, 3, 4, 5, 6, 7]:
        write_text_at_pos_keep_rest(chr(winddir), 0, winddir)

    for winddir in ["N", "NE", "E", "SE", "S", "SW", "W", "NW"]:
        wind_dir_int = int(map_wind2arrow[winddir])  # pylint: disable=C0103  # UPPER_CASE
        print(f'{winddir:<2} map_wind2arrow[winddir] {wind_dir_int}')
        write_text_at_pos_keep_rest(chr(wind_dir_int), 1, wind_dir_int)
    # time.sleep(4)
    blink_one_second(40)  # 40 * 0.1 == 4 seconds

URL1 = ["https://api.open-meteo.com/v1/"](https://api.open-meteo.com/v1/)
URL2 = f'forecast?latitude={LAT}&longitude={LON}&timezone={TZ}'
URL3 = ''
# URL4 = "&current=temperature_2m,weather_code"
URL4 = ''  # default km/h &wind_speed_unit=ms
URL5 = "&hourly=temperature_2m,weather_code,wind_speed_10m,wind_direction_10m"
URL6 = f"&past_days=0&forecast_days=0&forecast_hours={HOURS}"


def main():
    last_update_time = 0
    weather_refresh_seconds = WEATHER_REFRESH_SECONDS

    while True:
        current_time = time.time()

        # Check if it's time to update weather data (every 15 minutes seems OK)
        if current_time - last_update_time >= weather_refresh_seconds:
            weather_data = fetch_weather()  # Fetch weather data
            last_update_time = current_time  # Update last update time

            base_screens = setup_weather_screens(weather_data)

        display_weather(base_screens)  # Display weather data


if __NAME__ == "__main__":
    log_to_file(time.localtime(), f"UTC 1 main to be started, run as name = {__NAME__}")
    main()
    log_to_file(time.localtime(), f"UTC 1 main has ended")
elif __NAME__ == "auto_start.py":
    log_to_file(time.localtime(), f"UTC 2 main to be started, run as name = {__NAME__}")
    main()
    log_to_file(time.localtime(), f"UTC 2 main has ended")
else:
    log_to_file(time.localtime(), f"UTC 3 main did not run as name = {__NAME__}")

# ###################################
# finish:
lcd_off(lcd)
led.off()

log_to_file(time.localtime(), f"UTC {__NAME__} forecast program ended")

# #################### blink a led to show we DO stil work ##################

blink_one_second()  # Default 10 times 0.1 = 1 second

log_to_file(time.localtime(), f"UTC Program '{__NAME__}' ended - logfile print follows:")

print_logfile()

# ###################### the end #############################################

[Feature] Enable definition of special characters on the LCD. #7

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions