220 lines
6.6 KiB
Python
220 lines
6.6 KiB
Python
# SPDX-FileCopyrightText: 2018 Dave Astels for Adafruit Industries
|
|
#
|
|
# SPDX-License-Identifier: MIT
|
|
|
|
"""
|
|
The MIT License (MIT)
|
|
|
|
Copyright (c) 2018 Dave Astels
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
|
|
--------------------------------------------------------------------------------
|
|
|
|
EPROM emulator UI in CircuitPython.
|
|
Targeted for the SAMD51 boards.
|
|
|
|
by Dave Astels
|
|
"""
|
|
|
|
import sdcardio
|
|
import adafruit_ssd1306
|
|
import board
|
|
import busio
|
|
import digitalio
|
|
import storage
|
|
from adafruit_debouncer import Debouncer
|
|
from directory_node import DirectoryNode
|
|
from emulator import Emulator
|
|
|
|
# pylint: disable=global-statement
|
|
# --------------------------------------------------------------------------------
|
|
# Initialize Rotary encoder
|
|
|
|
# Encoder button is a digital input with pullup on D2
|
|
encoder_switch = digitalio.DigitalInOut(board.D2)
|
|
encoder_switch.direction = digitalio.Direction.INPUT
|
|
encoder_switch.pull = digitalio.Pull.UP
|
|
button = Debouncer(encoder_switch)
|
|
|
|
# Rotary encoder inputs with pullup on D3 & D4
|
|
rot_a = digitalio.DigitalInOut(board.D4)
|
|
rot_a.direction = digitalio.Direction.INPUT
|
|
rot_a.pull = digitalio.Pull.UP
|
|
|
|
rot_b = digitalio.DigitalInOut(board.D3)
|
|
rot_b.direction = digitalio.Direction.INPUT
|
|
rot_b.pull = digitalio.Pull.UP
|
|
|
|
# --------------------------------------------------------------------------------
|
|
# Initialize I2C and OLED
|
|
|
|
i2c = busio.I2C(board.SCL, board.SDA)
|
|
|
|
oled = adafruit_ssd1306.SSD1306_I2C(128, 32, i2c)
|
|
oled.fill(0)
|
|
oled.text("Initializing SD", 0, 10)
|
|
oled.show()
|
|
|
|
# --------------------------------------------------------------------------------
|
|
# Initialize SD card
|
|
|
|
# SD_CS = board.D10
|
|
# Connect to the card and mount the filesystem.
|
|
spi = busio.SPI(board.D13, board.D11, board.D12) # SCK, MOSI, MISO
|
|
sdcard = sdcardio.SDCard(spi, board.D10)
|
|
vfs = storage.VfsFat(sdcard)
|
|
storage.mount(vfs, "/sd")
|
|
|
|
oled.fill(0)
|
|
oled.text("Done", 0, 10)
|
|
oled.show()
|
|
|
|
# --------------------------------------------------------------------------------
|
|
# Initialize globals
|
|
|
|
encoder_counter = 0
|
|
encoder_direction = 0
|
|
|
|
# constants to help us track what edge is what
|
|
A_POSITION = 0
|
|
B_POSITION = 1
|
|
UNKNOWN_POSITION = -1 # initial state so we know if something went wrong
|
|
|
|
rising_edge = falling_edge = UNKNOWN_POSITION
|
|
|
|
PROGRAM_MODE = 0
|
|
EMULATE_MODE = 1
|
|
|
|
current_mode = PROGRAM_MODE
|
|
emulator = Emulator(i2c)
|
|
|
|
|
|
# --------------------------------------------------------------------------------
|
|
# Helper functions
|
|
|
|
def is_binary_name(filename):
|
|
return filename[-4:] == ".bin"
|
|
|
|
|
|
def load_file(filename):
|
|
data = []
|
|
with open(filename, "rb") as f:
|
|
data = f.read()
|
|
return data
|
|
|
|
|
|
def display_emulating_screen():
|
|
oled.fill(0)
|
|
oled.text("Emulating", 0, 0)
|
|
oled.text(current_dir.selected_filename, 0, 10)
|
|
oled.show()
|
|
|
|
|
|
# pylint: disable=global-statement
|
|
def emulate():
|
|
global current_mode
|
|
data = load_file(current_dir.selected_filepath)
|
|
emulator.load_ram(data)
|
|
emulator.enter_emulate_mode()
|
|
current_mode = EMULATE_MODE
|
|
display_emulating_screen()
|
|
|
|
|
|
# pylint: disable=global-statement
|
|
def program():
|
|
global current_mode
|
|
emulator.enter_program_mode()
|
|
current_mode = PROGRAM_MODE
|
|
current_dir.force_update()
|
|
|
|
|
|
# --------------------------------------------------------------------------------
|
|
# Main loop
|
|
|
|
current_dir = DirectoryNode(oled, name="/sd")
|
|
current_dir.force_update()
|
|
rising_edge = falling_edge = UNKNOWN_POSITION
|
|
rotary_prev_state = [rot_a.value, rot_b.value]
|
|
|
|
while True:
|
|
# reset encoder and wait for the next turn
|
|
encoder_direction = 0
|
|
|
|
# take a 'snapshot' of the rotary encoder state at this time
|
|
rotary_curr_state = [rot_a.value, rot_b.value]
|
|
|
|
# See https://learn.adafruit.com/media-dial/code
|
|
if rotary_curr_state != rotary_prev_state:
|
|
print("Was: {}".format(rotary_prev_state))
|
|
print("Now: {}".format(rotary_curr_state))
|
|
if rotary_prev_state == [True, True]:
|
|
if not rotary_curr_state[A_POSITION]:
|
|
print("Falling A")
|
|
falling_edge = A_POSITION
|
|
elif not rotary_curr_state[B_POSITION]:
|
|
print("Falling B")
|
|
falling_edge = B_POSITION
|
|
else:
|
|
continue
|
|
|
|
if rotary_curr_state == [True, True]:
|
|
if not rotary_prev_state[B_POSITION]:
|
|
rising_edge = B_POSITION
|
|
print("Rising B")
|
|
elif not rotary_prev_state[A_POSITION]:
|
|
rising_edge = A_POSITION
|
|
print("Rising A")
|
|
else:
|
|
continue
|
|
|
|
# check first and last edge
|
|
if (rising_edge == A_POSITION) and (falling_edge == B_POSITION):
|
|
encoder_counter -= 1
|
|
encoder_direction = -1
|
|
print("%d dec" % encoder_counter)
|
|
elif (rising_edge == B_POSITION) and (falling_edge == A_POSITION):
|
|
encoder_counter += 1
|
|
encoder_direction = 1
|
|
print("%d inc" % encoder_counter)
|
|
else:
|
|
# (shrug) something didn't work out, oh well!
|
|
encoder_direction = 0
|
|
|
|
# reset our edge tracking
|
|
rising_edge = falling_edge = UNKNOWN_POSITION
|
|
|
|
rotary_prev_state = rotary_curr_state
|
|
|
|
# Handle encoder rotation
|
|
if current_mode == PROGRAM_MODE: # Ignore rotation if in EMULATE mode
|
|
if encoder_direction == -1:
|
|
current_dir.up()
|
|
elif encoder_direction == 1:
|
|
current_dir.down()
|
|
|
|
# look for a press of the rotary encoder switch press, with debouncing
|
|
button.update()
|
|
if button.fell:
|
|
if current_mode == EMULATE_MODE:
|
|
program()
|
|
elif is_binary_name(current_dir.selected_filename):
|
|
emulate()
|
|
else:
|
|
current_dir = current_dir.click()
|