# SPDX-FileCopyrightText: 2022 Jeff Epler, written for Adafruit Industries
#
# SPDX-License-Identifier: MIT
# Modified 21 April 2023 Bruce Wilson to show usage with Class, and issue with using sideset on the same pin.
# Run the program, then call one of
#   morseClassSamePin()
#   morseClassAltPin() 
#   morseSamePin()
#   morseAltPin()

"""Demonstrate background writing, including loop writing, with morse code.

On any rp2040 board with board.LED, this will alternately send 'SOS' and 'TEST'
via the LED, demonstrating that Python code continues to run while the morse
code data is transmitted. Alternately, change one line below to make it send
'TEST' forever in a loop, again while Python code continues to run.

The combination of "LED status" and duration is sent to the PIO as 16-bit number:
The top bit is 1 if the LED is turned on and 0 otherwise.  The other 15 bits form a delay
value from 1 to 32767. A subset of the morse code 'alphabit' is created, with everthing
based on the 'DIT duration' of about 128ms (1MHz / 32 / 4000).

https://en.wikipedia.org/wiki/Morse_code
"""

import array
import time
import board
import rp2pio
from adafruit_pioasm import Program
from rp2pio import StateMachine

myLEDpin = board.LED
mySidePin = board.GP0

pio_code = Program(
    """
    .side_set 1 opt
        pull
        out x, 1
        mov pins, x
        out x, 15
    busy_wait:
        nop	[7]
        nop	[7]
        nop	[7]
        jmp x--, busy_wait [7]
        """
)

# The top bit of the command is the LED value, on or off
LED_ON = 0x8000
LED_OFF = 0x0000

# The other 15 bits are a delay duration.
# It must be the case that 4 * DIT_DURATION < 32768
DIT_DURATION = 4000
DAH_DURATION = 3 * DIT_DURATION

# Build up some elements of morse code, based on the wikipedia article.
DIT = array.array("H", [LED_ON | DIT_DURATION, LED_OFF | DIT_DURATION])
DAH = array.array("H", [LED_ON | DAH_DURATION, LED_OFF | DIT_DURATION])
# That is, two more DAH-length gaps for a total of three
LETTER_SPACE = array.array("H", [LED_OFF | (2 * DAH_DURATION)])
# That is, four more DAH-length gaps (after a letter space) for a total of seven
WORD_SPACE = array.array("H", [LED_OFF | (4 * DIT_DURATION)])

# Letters and words can be created by concatenating ("+") the elements
E = DIT + LETTER_SPACE
O = DAH + DAH + DAH + LETTER_SPACE
S = DIT + DIT + DIT + LETTER_SPACE
T = DAH + LETTER_SPACE
SOS = S + O + S + WORD_SPACE
TEST = T + E + S + T + WORD_SPACE


class MORSE:
    def __init__(self, *, led_pin, side_pin):
        self.pio = rp2pio.StateMachine(
            pio_code.assembled,
            first_out_pin=led_pin,
            first_sideset_pin=side_pin,
            frequency=1000000,
            auto_pull=False,
            initial_sideset_pin_state=1,
            initial_sideset_pin_direction=1,
            initial_out_pin_state=0,
            initial_out_pin_direction=1,
            out_shift_right=False,
            **pio_code.pio_kwargs,
        )
    def write(self, buf):
        print ("writing")
        return self.pio.write(buf)
  
def morseClassSamePin():
    myMorse = MORSE(led_pin = myLEDpin, side_pin = myLEDpin)
    while True:
        myMorse.write(SOS)
        time.sleep(2)

def morseClassAltPin():
    myMorse = MORSE(led_pin = myLEDpin, side_pin = mySidePin)
    while True:
        myMorse.write(SOS)
        time.sleep(2)

def morseAltPin():
    sm = StateMachine(
        pio_code.assembled,
        frequency=1_000_000,
        first_out_pin=myLEDpin,
        first_sideset_pin=mySidePin,
        pull_threshold=16,
        auto_pull=False,
        out_shift_right=False,
        initial_sideset_pin_state=1,
        initial_sideset_pin_direction=1,
        initial_out_pin_state=0,
        initial_out_pin_direction=1,
    )
    while True:
        for plain, morse in (
            ("SOS", SOS),
            ("TEST", TEST),
        ):
            print(f"Sending out {plain}", end="")
            sm.background_write(morse)
            sm.clear_txstall()
            while not sm.txstall:
                print(end=".")
                time.sleep(0.1)
            print()
            print("Message all sent to StateMachine (including emptying FIFO)")
            print()
            time.sleep(2)


def morseSamePin():
    sm = StateMachine(
        pio_code.assembled,
        frequency=1_000_000,
        first_out_pin=myLEDpin,
        first_sideset_pin=myLEDpin,
        pull_threshold=16,
        auto_pull=False,
        out_shift_right=False,
        initial_sideset_pin_state=1,
        initial_sideset_pin_direction=1,
        initial_out_pin_state=1,
        initial_out_pin_direction=1,
    )
    while True:
        for plain, morse in (
            ("SOS", SOS),
            ("TEST", TEST),
        ):
            print(f"Sending out {plain}", end="")
            sm.background_write(morse)
            sm.clear_txstall()
            while not sm.txstall:
                print(end=".")
                time.sleep(0.1)
            print()
            print("Message all sent to StateMachine (including emptying FIFO)")
            print()
            time.sleep(2)