LogicFlipTest.py

# Flip-dot dual-panel starburst ring test using existing helpers, ASCII only

import serial
import fcntl
import struct
import time
import numpy as np
import sys
import random
import socket

#*******************************************************************************
# Font table (needed for helper functions, even if not used in this test)
#*******************************************************************************
abc = [
    0x00, 0x00, 0x00, 0x00, 0x00,
    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,
    0x00, 0x42, 0x7F, 0x40, 0x00,
    0x42, 0x61, 0x51, 0x49, 0x46,
    0x21, 0x41, 0x45, 0x4B, 0x31,
    0x18, 0x14, 0x12, 0x7F, 0x10,
    0x27, 0x45, 0x45, 0x45, 0x39,
    0x3C, 0x4A, 0x49, 0x49, 0x30,
    0x01, 0x71, 0x09, 0x05, 0x03,
    0x36, 0x49, 0x49, 0x49, 0x36,
    0x06, 0x49, 0x49, 0x29, 0x1E,
    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,
    0x7F, 0x49, 0x49, 0x49, 0x36,
    0x3E, 0x41, 0x41, 0x41, 0x22,
    0x7F, 0x41, 0x41, 0x22, 0x1C,
    0x7F, 0x49, 0x49, 0x49, 0x41,
    0x7F, 0x09, 0x09, 0x01, 0x01,
    0x3E, 0x41, 0x41, 0x51, 0x32,
    0x7F, 0x08, 0x08, 0x08, 0x7F,
    0x00, 0x41, 0x7F, 0x41, 0x00,
    0x20, 0x40, 0x41, 0x3F, 0x01,
    0x7F, 0x08, 0x14, 0x22, 0x41,
    0x7F, 0x40, 0x40, 0x40, 0x40,
    0x7F, 0x02, 0x04, 0x02, 0x7F,
    0x7F, 0x04, 0x08, 0x10, 0x7F,
    0x3E, 0x41, 0x41, 0x41, 0x3E,
    0x7F, 0x09, 0x09, 0x09, 0x06,
    0x3E, 0x41, 0x51, 0x21, 0x5E,
    0x7F, 0x09, 0x19, 0x29, 0x46,
    0x46, 0x49, 0x49, 0x49, 0x31,
    0x01, 0x01, 0x7F, 0x01, 0x01,
    0x3F, 0x40, 0x40, 0x40, 0x3F,
    0x1F, 0x20, 0x40, 0x20, 0x1F,
    0x7F, 0x20, 0x18, 0x20, 0x7F,
    0x63, 0x14, 0x08, 0x14, 0x63,
    0x03, 0x04, 0x78, 0x04, 0x03,
    0x61, 0x51, 0x49, 0x45, 0x43,
    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,
    0x7F, 0x48, 0x44, 0x44, 0x38,
    0x38, 0x44, 0x44, 0x44, 0x20,
    0x38, 0x44, 0x44, 0x48, 0x7F,
    0x38, 0x54, 0x54, 0x54, 0x18,
    0x08, 0x7E, 0x09, 0x01, 0x02,
    0x08, 0x14, 0x54, 0x54, 0x3C,
    0x7F, 0x08, 0x04, 0x04, 0x78,
    0x00, 0x44, 0x7D, 0x40, 0x00,
    0x20, 0x40, 0x44, 0x3D, 0x00,
    0x00, 0x7F, 0x10, 0x28, 0x44,
    0x00, 0x41, 0x7F, 0x40, 0x00,
    0x7C, 0x04, 0x18, 0x04, 0x78,
    0x7C, 0x08, 0x04, 0x04, 0x78,
    0x38, 0x44, 0x44, 0x44, 0x38,
    0x7C, 0x14, 0x14, 0x14, 0x08,
    0x08, 0x14, 0x14, 0x18, 0x7C,
    0x7C, 0x08, 0x04, 0x04, 0x08,
    0x48, 0x54, 0x54, 0x54, 0x20,
    0x04, 0x3F, 0x44, 0x40, 0x20,
    0x3C, 0x40, 0x40, 0x20, 0x7C,
    0x1C, 0x20, 0x40, 0x20, 0x1C,
    0x3C, 0x40, 0x30, 0x40, 0x3C,
    0x44, 0x28, 0x10, 0x28, 0x44,
    0x0C, 0x50, 0x50, 0x50, 0x3C,
    0x44, 0x64, 0x54, 0x4C, 0x44,
    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,
]
abcIdx = np.arange(0, 96 * 5, 5)

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

ser.close()
ser.open()

TIOCSRS485 = 0x542F

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)

RS485_FLAGS = SER_RS485_ENABLED | SER_RS485_USE_GPIO
RS485_RTS_GPIO_PIN = 48

serial_rs485 = struct.pack(
    'IIIIIIII',
    RS485_FLAGS,
    0,
    0,
    RS485_RTS_GPIO_PIN,
    0, 0, 0, 0
)

fd = ser.fileno()
fcntl.ioctl(fd, TIOCSRS485, serial_rs485)

#*******************************************************************************
# Display geometry and addressing (matches your main code)
#*******************************************************************************
cols = 56
rows = 7
cmd = 0x83
adr0 = 0x00
adr1 = 0x01

#*******************************************************************************
# 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)
    char0offset = char0int - 32
    char0array = [0] * 6

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

    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 plus 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,
        struct.pack('256s', ifname[:15])
    )[20:24])

#*******************************************************************************
# 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 test loop
#*******************************************************************************

print "Running repeating starburst wipe test on 56x7 display..."
time.sleep(1.0)

while 1:
    #starburst_wipe(num_bursts=5, frame_delay=0.05)
    chevron_sweep_wipe()
    time.sleep(2.0)

# Not reached, but here for completeness
ser.close()