LogicFlipShiftTime4-chevron.py

import serial
import fcntl
import struct
import time
import numpy as np
import sys
import random
import ntplib
from datetime import datetime, tzinfo, timedelta
import socket, fcntl, struct
import pytz
from pytz import timezone
import subprocess  # used to call out to `date` to set system time

#*******************************************************************************
# 5x7 Font Table (plus spacing column)
#*******************************************************************************
# Each character is 5 columns wide, plus a 6th zero column used as spacing.
# Characters are stored from ASCII 32 (" ") to 127, in order.
abc = [
    0x00, 0x00, 0x00, 0x00, 0x00, # (space)
    0x00, 0x00, 0x5F, 0x00, 0x00, # !
    0x00, 0x07, 0x00, 0x07, 0x00, # "
    0x14, 0x7F, 0x14, 0x7F, 0x14, # #
    0x24, 0x2A, 0x7F, 0x2A, 0x12, # $
    0x23, 0x13, 0x08, 0x64, 0x62, # %
    0x36, 0x49, 0x55, 0x22, 0x50, # &
    0x00, 0x05, 0x03, 0x00, 0x00, # '
    0x00, 0x1C, 0x22, 0x41, 0x00, # (
    0x00, 0x41, 0x22, 0x1C, 0x00, # )
    0x08, 0x2A, 0x1C, 0x2A, 0x08, # *
    0x08, 0x08, 0x3E, 0x08, 0x08, # +
    0x00, 0x50, 0x30, 0x00, 0x00, # ,
    0x08, 0x08, 0x08, 0x08, 0x08, # -
    0x00, 0x60, 0x60, 0x00, 0x00, # .
    0x20, 0x10, 0x08, 0x04, 0x02, # /
    0x3E, 0x51, 0x49, 0x45, 0x3E, # 0
    0x00, 0x42, 0x7F, 0x40, 0x00, # 1
    0x42, 0x61, 0x51, 0x49, 0x46, # 2
    0x21, 0x41, 0x45, 0x4B, 0x31, # 3
    0x18, 0x14, 0x12, 0x7F, 0x10, # 4
    0x27, 0x45, 0x45, 0x45, 0x39, # 5
    0x3C, 0x4A, 0x49, 0x49, 0x30, # 6
    0x01, 0x71, 0x09, 0x05, 0x03, # 7
    0x36, 0x49, 0x49, 0x49, 0x36, # 8
    0x06, 0x49, 0x49, 0x29, 0x1E, # 9
    0x00, 0x36, 0x36, 0x00, 0x00, # :
    0x00, 0x56, 0x36, 0x00, 0x00, # ;
    0x00, 0x08, 0x14, 0x22, 0x41, # <
    0x14, 0x14, 0x14, 0x14, 0x14, # =
    0x41, 0x22, 0x14, 0x08, 0x00, # >
    0x02, 0x01, 0x51, 0x09, 0x06, # ?
    0x32, 0x49, 0x79, 0x41, 0x3E, # @
    0x7E, 0x11, 0x11, 0x11, 0x7E, # A
    0x7F, 0x49, 0x49, 0x49, 0x36, # B
    0x3E, 0x41, 0x41, 0x41, 0x22, # C
    0x7F, 0x41, 0x41, 0x22, 0x1C, # D
    0x7F, 0x49, 0x49, 0x49, 0x41, # E
    0x7F, 0x09, 0x09, 0x01, 0x01, # F
    0x3E, 0x41, 0x41, 0x51, 0x32, # G
    0x7F, 0x08, 0x08, 0x08, 0x7F, # H
    0x00, 0x41, 0x7F, 0x41, 0x00, # I
    0x20, 0x40, 0x41, 0x3F, 0x01, # J
    0x7F, 0x08, 0x14, 0x22, 0x41, # K
    0x7F, 0x40, 0x40, 0x40, 0x40, # L
    0x7F, 0x02, 0x04, 0x02, 0x7F, # M
    0x7F, 0x04, 0x08, 0x10, 0x7F, # N
    0x3E, 0x41, 0x41, 0x41, 0x3E, # O
    0x7F, 0x09, 0x09, 0x09, 0x06, # P
    0x3E, 0x41, 0x51, 0x21, 0x5E, # Q
    0x7F, 0x09, 0x19, 0x29, 0x46, # R
    0x46, 0x49, 0x49, 0x49, 0x31, # S
    0x01, 0x01, 0x7F, 0x01, 0x01, # T
    0x3F, 0x40, 0x40, 0x40, 0x3F, # U
    0x1F, 0x20, 0x40, 0x20, 0x1F, # V
    0x7F, 0x20, 0x18, 0x20, 0x7F, # W
    0x63, 0x14, 0x08, 0x14, 0x63, # X
    0x03, 0x04, 0x78, 0x04, 0x03, # Y
    0x61, 0x51, 0x49, 0x45, 0x43, # Z
    0x00, 0x00, 0x7F, 0x41, 0x41, # [
    0x02, 0x04, 0x08, 0x10, 0x20, # "\"
    0x41, 0x41, 0x7F, 0x00, 0x00, # ]
    0x04, 0x02, 0x01, 0x02, 0x04, # ^
    0x40, 0x40, 0x40, 0x40, 0x40, # _
    0x00, 0x01, 0x02, 0x04, 0x00, # `
    0x20, 0x54, 0x54, 0x54, 0x78, # a
    0x7F, 0x48, 0x44, 0x44, 0x38, # b
    0x38, 0x44, 0x44, 0x44, 0x20, # c
    0x38, 0x44, 0x44, 0x48, 0x7F, # d
    0x38, 0x54, 0x54, 0x54, 0x18, # e
    0x08, 0x7E, 0x09, 0x01, 0x02, # f
    0x08, 0x14, 0x54, 0x54, 0x3C, # g
    0x7F, 0x08, 0x04, 0x04, 0x78, # h
    0x00, 0x44, 0x7D, 0x40, 0x00, # i
    0x20, 0x40, 0x44, 0x3D, 0x00, # j
    0x00, 0x7F, 0x10, 0x28, 0x44, # k
    0x00, 0x41, 0x7F, 0x40, 0x00, # l
    0x7C, 0x04, 0x18, 0x04, 0x78, # m
    0x7C, 0x08, 0x04, 0x04, 0x78, # n
    0x38, 0x44, 0x44, 0x44, 0x38, # o
    0x7C, 0x14, 0x14, 0x14, 0x08, # p
    0x08, 0x14, 0x14, 0x18, 0x7C, # q
    0x7C, 0x08, 0x04, 0x04, 0x08, # r
    0x48, 0x54, 0x54, 0x54, 0x20, # s
    0x04, 0x3F, 0x44, 0x40, 0x20, # t
    0x3C, 0x40, 0x40, 0x20, 0x7C, # u
    0x1C, 0x20, 0x40, 0x20, 0x1C, # v
    0x3C, 0x40, 0x30, 0x40, 0x3C, # w
    0x44, 0x28, 0x10, 0x28, 0x44, # x
    0x0C, 0x50, 0x50, 0x50, 0x3C, # y
    0x44, 0x64, 0x54, 0x4C, 0x44, # z
    0x00, 0x08, 0x36, 0x41, 0x00, # {
    0x00, 0x00, 0x7F, 0x00, 0x00, # |
    0x00, 0x41, 0x36, 0x08, 0x00, # }
    0x08, 0x08, 0x2A, 0x1C, 0x08, # ->
    0x08, 0x1C, 0x2A, 0x08, 0x08, # <-
]

# Precompute character offsets into the font table
abcIdx = np.arange(0, 96 * 5, 5)

#*******************************************************************************
# RS-485 Serial Port Setup
#*******************************************************************************
ser = serial.Serial(
    port='/dev/ttyO4',
    baudrate=38400,
    timeout=1,
    parity=serial.PARITY_NONE,
    stopbits=serial.STOPBITS_ONE,
    bytesize=serial.EIGHTBITS
)

# Standard Linux RS485 ioctl constant
TIOCSRS485 = 0x542F

# Bit flags for RS485 configuration
SER_RS485_ENABLED         = (1 << 0)
SER_RS485_RTS_ON_SEND     = (1 << 1)
SER_RS485_RTS_AFTER_SEND  = (1 << 2)
SER_RS485_RTS_BEFORE_SEND = (1 << 3)
SER_RS485_USE_GPIO        = (1 << 5)

# We use a GPIO line to control RE/DE on the transceiver
RS485_FLAGS = SER_RS485_ENABLED | SER_RS485_USE_GPIO

# Kernel GPIO number used for RS485 direction control
RS485_RTS_GPIO_PIN = 48  # GPIO1_16 -> 1*32 + 16 = 48

# Pack into struct serial_rs485 layout (8 unsigned 32 bit values)
serial_rs485 = struct.pack(
    'IIIIIIII',
    RS485_FLAGS,        # config flags
    0,                  # delay before send (us)
    0,                  # delay after send (us)
    RS485_RTS_GPIO_PIN, # GPIO pin for DE/RE
    0, 0, 0, 0          # padding
)

# Apply RS485 configuration to the open serial port
fd = ser.fileno()
fcntl.ioctl(fd, TIOCSRS485, serial_rs485)

#*******************************************************************************
# Helper Functions
#*******************************************************************************

def sendPack(cmd, addr, data):
    """
    Send a 28 byte data packet to the flip-dot controller.

    Packet format:
      0x80   - header
      cmd    - command byte
      addr   - panel address
      28 bytes of column data
      0x8F   - end byte
    """
    ByteHeader = 0x80
    ByteEnd = 0x8F
    ByteCols = 28

    ser.write(chr(ByteHeader))
    ser.write(chr(cmd))
    ser.write(chr(addr))

    for n in range(0, ByteCols):
        ser.write(chr(data[n]))

    ser.write(chr(ByteEnd))


def flipRand(size):
    """Generate a list of 'size' random bytes from 0 to 255."""
    result = [0] * size
    for n in range(0, size):
        result[n] = random.randrange(0, 256, 1)
    return result


def shift(key, array):
    """
    Circularly shift an array by 'key' positions to the left.

    Used to scroll messages across the display.
    """
    return array[key % len(array):] + array[:key % len(array)]


def charLook(char0):
    """
    Map a single ASCII character to a 6 column font pattern.

    The first 5 columns come from the font table, the 6th is a blank spacer.
    """
    char0int = ord(char0)          # ASCII code
    char0offset = char0int - 32    # index into abc table (starts at space)
    char0array = [0] * 6

    for x in range(0, 5):
        char0array[x] = abc[abcIdx[char0offset] + x]

    # trailing blank column as spacing
    char0array[5] = 0
    return char0array


def loadMessage(mString):
    """
    Convert an entire string into a flat list of column bytes.

    Each character contributes 6 columns (5 for glyph + 1 spacing).
    """
    result = [0] * len(mString) * 6
    ctr = 0
    for m in range(0, len(mString)):
        charData = charLook(mString[m])
        for n in range(0, 6):
            result[ctr] = charData[n]
            ctr += 1
    return result


def loadFrame(size, data):
    """
    Copy up to 'size' bytes from data into a frame, pad with zeros otherwise.

    This ensures the frame list is always exactly 'size' long.
    """
    result = [0] * size
    for m in range(0, size):
        if m < len(data):
            result[m] = data[m]
        else:
            result[m] = 0
    return result


def get_ip_address(ifname):
    """
    Return the IPv4 address for a given network interface name (e.g. 'wlan2').

    Uses ioctl SIOCGIFADDR on a dummy socket.
    """
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    return socket.inet_ntoa(fcntl.ioctl(
        s.fileno(),
        0x8915,                        # SIOCGIFADDR
        struct.pack('256s', ifname[:15])
    )[20:24])

#*******************************************************************************
# Time Zone Helper Classes and NTP Check
#*******************************************************************************

class Zone(tzinfo):
    """
    Simple fixed-offset time zone class.

    Used mainly for formatting local times in GMT/EST/EDT.
    """
    def __init__(self, offset, isdst, name):
        self.offset = offset
        self.isdst = isdst
        self.name = name

    def utcoffset(self, dt):
        return timedelta(hours=self.offset) + self.dst(dt)

    def dst(self, dt):
        return timedelta(hours=1) if self.isdst else timedelta(0)

    def tzname(self, dt):
        return self.name


GMT = Zone(0, False, 'GMT')
EST = Zone(-5, False, 'EST')
EDT = Zone(-4, False, 'EDT')


def check_ntp_time():
    """
    Query an NTP server and set the system clock to match.

    This uses the `date` command via subprocess and requires root privileges.
    It also prints some debug information about the synchronized time.
    """
    try:
        x = ntplib.NTPClient()
        response = x.request('pool.ntp.org')

        # NTP server's transmit time as a UTC datetime
        utc_now = datetime.utcfromtimestamp(response.tx_time)

        # Format as a string acceptable to `date`
        # Example: "2025-03-01 14:23:05"
        date_str = utc_now.strftime('%Y-%m-%d %H:%M:%S')

        # Set the system time in UTC. `-u` tells date that the string is UTC.
        # This call will typically require the script to be run as root.
        rc = subprocess.call(['date', '-u', '-s', date_str])

        if rc != 0:
            print "Failed to set system time from NTP, date exited with code", rc
        else:
            print "System time set from NTP to:", date_str, "UTC"

        # Print some human-readable checks using the (now updated) system clock
        print datetime.utcnow().strftime('UTC = %m/%d/%Y %H:%M:%S %Z')
        print datetime.now(GMT).strftime('GMT = %m/%d/%Y %H:%M:%S %Z')
        print datetime.now(EST).strftime('EST = %m/%d/%Y %H:%M:%S %Z')
        print datetime.now(EST).strftime('MSG = %H:%M %a')

    except Exception as e:
        # In production you might want to log this instead of only printing.
        print "NTP check / system time update failed:", e

#*******************************************************************************
# Display Setup and Initial Effects
#*******************************************************************************

# Display geometry and addressing
cols = 56
rows = 7
cmd = 0x83
adr0 = 0x00
adr1 = 0x01

# Predefined frames for blanking and testing
flipWht = [255] * cols
flipBlk = [0] * cols
flipOne = flipBlk
flipOne[0] = 255

# Message buffer variables
maxLength = 140
maxData = [0] * maxLength * 6
msgPad = '          '  # 10 spaces as padding
msg = msgPad + 'Time to Read Books!!!'
msgData = [0] * 140 * 6
msgPad = [0] * cols

# Blank the display a few times as a startup effect
for x in range(0, 5):
    sendPack(cmd, adr0, flipWht[28:56])
    sendPack(cmd, adr1, flipWht[28:56])
    time.sleep(1)
    sendPack(cmd, adr0, flipBlk[28:56])
    sendPack(cmd, adr1, flipBlk[28:56])

# Setup pytz timezone for local clock display
eastern = timezone('US/Eastern')

# Initial NTP sync at startup (sets the system clock)
check_ntp_time()

# After syncing, read the now-correct UTC time and compute the first message
utc_dt = datetime.now(pytz.utc)
loc_dt = utc_dt.astimezone(eastern)
msgDst = loc_dt.strftime('%H:%M %a')
print msgDst

# Scroll the IP address of the specified interface across the display
print get_ip_address('wlan2')
msg = ' ' + get_ip_address('wlan2') + ' '
msgData = loadMessage(msg)

for m in range(0, 125):
    msgData = shift(1, msgData)
    frame = loadFrame(cols, msgData)
    sendPack(cmd, adr0, frame[0:28])
    sendPack(cmd, adr1, frame[28:56])
    time.sleep(0.1)

#*******************************************************************************
# Starburst ring wipe across both panels (56 x rows)
#*******************************************************************************

def sendFrame56(frame):
    """
    Send a 56 column frame using the existing sendPack helper.
    Left 28 columns go to adr0, right 28 to adr1.
    """
    sendPack(cmd, adr0, frame[0:28])
    sendPack(cmd, adr1, frame[28:56])


def chevron_sweep_wipe(frame_delay=0.04, chevron_width=3):
    """
    Wipe the display from the center outward.

    '<<<' starts near the center and moves left.
    '>>>' starts near the center and moves right.
    The region between them is forced to black each frame, so it erases text.
    """

    totalCols = cols
    panelRows = rows
    mid = panelRows // 2  # 3 for 7 rows

    center_left = (totalCols // 2) - 1   # 27 for 56 cols
    center_right = (totalCols // 2)      # 28 for 56 cols

    def draw_single_chevron(grid, tip_x, direction):
        # direction: -1 for '<' (opens right), +1 for '>' (opens left)
        for y in range(panelRows):
            dx = abs(y - mid)
            if direction == -1:
                x = tip_x + dx
            else:
                x = tip_x - dx
            if 0 <= x < totalCols:
                grid[y][x] = 1

    def grid_to_frame(grid):
        frame = [0] * totalCols
        for x in range(totalCols):
            col_byte = 0
            for y in range(panelRows):
                if grid[y][x]:
                    col_byte |= (1 << y)
            frame[x] = col_byte
        return frame

    # Start tips at the center split and move outward
    left_tip = center_left
    right_tip = center_right

    # Continue until both tips have moved fully off-screen
    while left_tip > -mid or right_tip < totalCols + mid:

        # Everything starts black; we draw only the moving chevrons
        grid = [[0 for x in range(totalCols)] for y in range(panelRows)]

        # Draw '<<<' moving left
        for i in range(chevron_width):
            draw_single_chevron(grid, left_tip - i, -1)

        # Draw '>>>' moving right
        for i in range(chevron_width):
            draw_single_chevron(grid, right_tip + i, +1)

        sendFrame56(grid_to_frame(grid))
        time.sleep(frame_delay)

        # Move outward
        left_tip -= 1
        right_tip += 1

    # End on full black
    sendFrame56([0] * totalCols)
    time.sleep(0.05)


#*******************************************************************************
# Main Loop - Show Time, Periodically Recheck NTP, and Run Top-of-Hour Wipe
#*******************************************************************************

# Track the last time we checked NTP, and how often to recheck (in seconds)
last_ntp_check = time.time()
ntp_check_interval = 60 * 60  # one hour

# Track the last hour when we ran the starburst wipe
last_wipe_hour = None

while 1:

    # Recheck NTP once per hour to keep system time aligned
    now_secs = time.time()
    if now_secs - last_ntp_check >= ntp_check_interval:
        check_ntp_time()
        last_ntp_check = now_secs

    # Get current local time in Eastern
    utc_dt = datetime.now(pytz.utc)
    loc_dt = utc_dt.astimezone(eastern)

    # Top-of-hour detection: if minute == 0 and we have not yet wiped this hour
    if loc_dt.minute == 0 and loc_dt.second < 2:
        if last_wipe_hour != loc_dt.hour:
            chevron_sweep_wipe()
            last_wipe_hour = loc_dt.hour
            # Recompute time after the wipe animation completes
            utc_dt = datetime.now(pytz.utc)
            loc_dt = utc_dt.astimezone(eastern)
    # If we are away from the top of the hour and last_wipe_hour is None,
    # initialize it so we do not accidentally re-wipe until the next hour.
    elif last_wipe_hour is None:
        last_wipe_hour = loc_dt.hour

    # Format time string as "HH:MM Day"
    msgDst = loc_dt.strftime('%H:%M %a')

    # Convert time string to font columns and send to both halves of the display
    msgData = loadMessage(msgDst)
    frame = loadFrame(cols, msgData)
    sendPack(cmd, adr0, frame[0:28])
    sendPack(cmd, adr1, frame[28:56])

    # Roughly one update per second
    time.sleep(0.9)

# This is never reached in normal operation, but included for completeness.
ser.close()