329 lines
8.4 KiB
Python
329 lines
8.4 KiB
Python
# (c) Copyright 2018 by Coinkite Inc. This file is covered by license found in COPYING-CC.
|
|
#
|
|
# selftest.py - Interactive Selftest code
|
|
#
|
|
import ckcc
|
|
from uasyncio import sleep_ms
|
|
from glob import dis
|
|
from ux import ux_wait_keyup, ux_clear_keys, ux_poll_key
|
|
from ux import ux_show_story
|
|
from callgate import get_is_bricked, get_genuine, clear_genuine
|
|
from utils import problem_file_line
|
|
import version
|
|
from glob import settings
|
|
from charcodes import KEY_ENTER, KEY_CANCEL
|
|
|
|
try:
|
|
from display import FontLarge
|
|
except ImportError:
|
|
FontLarge = None
|
|
|
|
async def wait_ok():
|
|
k = await ux_wait_keyup('xy' + KEY_ENTER + KEY_CANCEL)
|
|
if k not in 'y' + KEY_ENTER:
|
|
raise RuntimeError('Canceled')
|
|
|
|
def label_test(line1, line2=''):
|
|
dis.clear()
|
|
if version.has_qwerty:
|
|
dis.text(None, 1, line1)
|
|
dis.text(None, 3, line2)
|
|
else:
|
|
dis.text(None, 10, line1)
|
|
dis.text(None, 34, line2, font=FontLarge)
|
|
dis.show()
|
|
|
|
async def test_numpad():
|
|
# do an interactive self test
|
|
|
|
keys = list('123456789x0y')
|
|
|
|
for ch in keys:
|
|
dis.clear()
|
|
dis.text(0,0, "Numpad Test. Press:")
|
|
dis.text(None,24, ch if ch != 'y' else 'OK', FontLarge)
|
|
dis.show()
|
|
|
|
k = await ux_wait_keyup(ch + 'x')
|
|
if k == 'x' and ch != 'x':
|
|
raise RuntimeError("numpad test aborted")
|
|
assert k == ch
|
|
|
|
async def test_keyboard():
|
|
# for Q1
|
|
# XXX
|
|
pass
|
|
|
|
async def test_qr_scanner():
|
|
# QR Scanner module: assume pretested, just testing connection
|
|
from glob import SCAN
|
|
assert SCAN
|
|
assert SCAN.version.startswith('V2.3.')
|
|
|
|
def set_genuine():
|
|
# PIN must be blank for this to work
|
|
# - or logged in already as main
|
|
from pincodes import pa
|
|
|
|
if pa.is_secondary:
|
|
return
|
|
|
|
if not pa.is_successful():
|
|
# assume blank pin during factory selftest
|
|
pa.setup(b'')
|
|
assert not pa.is_delay_needed() # "PIN failures?"
|
|
|
|
if not pa.is_successful():
|
|
pa.login()
|
|
assert pa.is_successful() # "PIN not blank?"
|
|
|
|
# do verify step
|
|
pa.greenlight_firmware()
|
|
|
|
dis.show()
|
|
|
|
async def test_secure_element():
|
|
|
|
assert not get_is_bricked() # bricked already
|
|
|
|
# test right chips installed
|
|
assert version.has_608 # expect 608
|
|
|
|
if ckcc.is_simulator(): return
|
|
|
|
for ph in range(5):
|
|
gg = get_genuine()
|
|
|
|
if version.has_qwerty:
|
|
dis.clear()
|
|
dis.text(0, 0, "^^-- Green? " if gg else " ^^-- Red?")
|
|
else:
|
|
dis.clear()
|
|
if gg:
|
|
dis.text(-1, 8, "Green ON? -->")
|
|
else:
|
|
dis.text(-1,50, "Red ON? -->")
|
|
|
|
dis.show()
|
|
await wait_ok()
|
|
|
|
if ph and gg:
|
|
# stop once it's on and we've tested both states
|
|
return
|
|
|
|
# attempt to switch to other state
|
|
if gg:
|
|
clear_genuine()
|
|
else:
|
|
# very slow!
|
|
dis.fullscreen("Wait...")
|
|
set_genuine()
|
|
ux_clear_keys()
|
|
|
|
ng = get_genuine()
|
|
assert ng != gg # "Could not invert LED"
|
|
|
|
async def test_sd_active():
|
|
# Mark 2+: SD Card active light.
|
|
# Q1: dual slots
|
|
from machine import Pin
|
|
|
|
for num in range(version.num_sd_slots):
|
|
|
|
led = Pin('SD_ACTIVE' if not num else 'SD_ACTIVE2', Pin.OUT)
|
|
|
|
for ph in range(2):
|
|
gg = not ph
|
|
led.value(gg)
|
|
|
|
if version.has_qwerty:
|
|
dis.clear()
|
|
if num == 0:
|
|
dis.text(0, 2, "<-- SD A is %s? " % ('ON' if gg else 'off'))
|
|
else:
|
|
dis.text(0, 7, "<-- SD B is %s? " % ('ON' if gg else 'off'))
|
|
else:
|
|
dis.clear()
|
|
if gg:
|
|
dis.text(0,16, "<-- Green ON?")
|
|
else:
|
|
dis.text(0,16, "<-- Green off?")
|
|
dis.show()
|
|
|
|
await wait_ok()
|
|
|
|
async def test_usb_light():
|
|
# Mk4's new USB activity light (right by connector)
|
|
from machine import Pin
|
|
p = Pin('USB_ACTIVE', Pin.OUT)
|
|
|
|
try:
|
|
p.value(1)
|
|
label_test("USB light is on?")
|
|
|
|
await wait_ok()
|
|
finally:
|
|
p.value(0)
|
|
|
|
async def test_nfc_light():
|
|
if not version.has_qwerty:
|
|
return
|
|
|
|
from machine import Pin
|
|
p = Pin('NFC_ACTIVE', Pin.OUT)
|
|
|
|
try:
|
|
p.value(1)
|
|
dis.clear()
|
|
dis.text(-1, -1, "NFC light green? --->")
|
|
dis.show()
|
|
|
|
await wait_ok()
|
|
finally:
|
|
p.value(0)
|
|
|
|
async def test_nfc():
|
|
# Mk4: NFC chip and field
|
|
if not version.has_nfc: return
|
|
from nfc import NFCHandler
|
|
await NFCHandler.selftest()
|
|
|
|
async def test_psram():
|
|
from glob import PSRAM
|
|
from ustruct import pack
|
|
import ngu
|
|
|
|
label_test('PSRAM Test')
|
|
|
|
test_len = PSRAM.length * 2
|
|
chk = bytearray(32)
|
|
spots = set()
|
|
for pos in range(0, PSRAM.length, 800 * 17):
|
|
if pos >= PSRAM.length: break
|
|
rnd = ngu.hash.sha256s(pack('I', pos))
|
|
|
|
PSRAM.write(pos, rnd)
|
|
PSRAM.read(pos, chk)
|
|
assert chk == rnd, "bad @ 0x%x" % pos
|
|
dis.progress_bar_show(pos / test_len)
|
|
spots.add(pos)
|
|
|
|
for pos in spots:
|
|
rnd = ngu.hash.sha256s(pack('I', pos))
|
|
PSRAM.read(pos, chk)
|
|
assert chk == rnd, "RB bad @ 0x%x" % pos
|
|
dis.progress_bar_show((PSRAM.length + pos) / test_len)
|
|
|
|
|
|
async def test_oled():
|
|
# all on/off tests
|
|
for ph in (1, 0):
|
|
dis.clear()
|
|
dis.dis.fill(ph)
|
|
dis.text(None,2, "Selftest", invert=ph)
|
|
dis.text(None,30, "All on?" if ph else 'All off?', invert=ph, font=FontLarge)
|
|
dis.show()
|
|
|
|
await wait_ok()
|
|
|
|
async def test_lcd():
|
|
# Very basic
|
|
try:
|
|
for nm, col in [('RED', 0xf800), ('GREEN', 0x07e0), ('BLUE', 0x001f)]:
|
|
dis.real_clear()
|
|
dis.dis.fill_screen(col)
|
|
dis.text(1,1, "Selftest")
|
|
dis.text(None,3, "All pixels are %s?" % nm)
|
|
dis.show()
|
|
|
|
await wait_ok()
|
|
finally:
|
|
dis.real_clear()
|
|
dis.draw_status(full=1)
|
|
dis.clear()
|
|
|
|
async def test_microsd():
|
|
#if ckcc.is_simulator(): return
|
|
from version import num_sd_slots
|
|
from files import CardSlot
|
|
import os
|
|
|
|
async def wait_til_state(num, want):
|
|
title = 'MicroSD Card'
|
|
if num_sd_slots > 1:
|
|
title += ' ' + chr(65+num)
|
|
label_test(title +':', 'Remove' if CardSlot.is_inserted() else 'Insert')
|
|
|
|
while 1:
|
|
if want == CardSlot.is_inserted(): return
|
|
await sleep_ms(100)
|
|
if ux_poll_key():
|
|
raise RuntimeError("MicroSD test aborted")
|
|
|
|
for slot_num in range(num_sd_slots):
|
|
# test presence switch
|
|
for ph in range(7):
|
|
await wait_til_state(slot_num, not CardSlot.is_inserted())
|
|
|
|
if ph >= 2 and CardSlot.is_inserted():
|
|
# debounce
|
|
await sleep_ms(100)
|
|
if CardSlot.is_inserted(): break
|
|
if ux_poll_key():
|
|
raise RuntimeError("MicroSD test aborted")
|
|
|
|
label_test('MicroSD Card:', 'Testing')
|
|
|
|
# card inserted
|
|
assert CardSlot.is_inserted() #, "SD not present?"
|
|
|
|
with CardSlot(slot_b=slot_num) as card:
|
|
|
|
_, fn = card.pick_filename('test-delme.txt')
|
|
|
|
with open(fn, 'wt') as fd:
|
|
fd.write("Hello")
|
|
with open(fn, 'rt') as fd:
|
|
assert fd.read() == "Hello"
|
|
|
|
os.unlink(fn)
|
|
|
|
# force removal, so cards don't get stuck in finished units
|
|
await wait_til_state(slot_num, False)
|
|
|
|
|
|
|
|
async def start_selftest():
|
|
|
|
try:
|
|
if not version.has_qwerty:
|
|
await test_oled()
|
|
else:
|
|
await test_lcd()
|
|
await test_psram()
|
|
await test_nfc_light()
|
|
await test_nfc()
|
|
if version.has_qwerty:
|
|
await test_keyboard()
|
|
else:
|
|
await test_numpad()
|
|
if version.has_qr:
|
|
await test_qr_scanner()
|
|
await test_secure_element()
|
|
await test_sd_active()
|
|
await test_usb_light()
|
|
await test_microsd()
|
|
|
|
# add more tests here
|
|
|
|
settings.set('tested', True)
|
|
await ux_show_story("Selftest complete", 'PASS')
|
|
dis.clear()
|
|
|
|
except (RuntimeError, AssertionError) as e:
|
|
e = str(e) or problem_file_line(e)
|
|
await ux_show_story("Test failed:\n" + str(e), 'FAIL')
|
|
|
|
|
|
# EOF
|