def connect(self, dev):
self.sd = SPIDriver(dev)
[w.Enable(True) for w in self.allw]
self.ckCS.SetValue(not self.sd.cs)
self.ckA.SetValue(self.sd.a)
self.ckB.SetValue(self.sd.b)
self.refresh(None)
def __init__(self, dev):
self.spi = SPIDriver(dev)
self.spi.setb(1)
if False:
self.spi.setb(0)
time.sleep(1)
self.spi.setb(1)
time.sleep(1)
self.coldstart()
t0 = time.time()
while self._rd32(gd3.REG_ID) != 0x7c:
assert (time.time() - t0) < 1.0, "No response - is GD attached?"
if 0:
time.sleep(1)
print("ID %8x" % self._rd32(gd3.REG_ID))
print("CMD_READ %8x" % self._rd32(gd3.REG_CMD_READ))
print("CMD_WRITE %8x" % self._rd32(gd3.REG_CMD_WRITE))
print("CMD_SPACE %8x" % self._rd32(gd3.REG_CMDB_SPACE))
while self._rd32(gd3.REG_ID) != 0x7c:
time.sleep(.1)
self.getspace()
self.stream()
def __init__(self, dev):
self.d = SPIDriver(dev)
self.d.unsel()
self.d.seta(1)
self.d.setb(1)
print('reset')
self.d.setb(0)
time.sleep(.1)
self.d.setb(1)
def __init__(self):
self.d = SPIDriver(
"/dev/serial/by-id/usb-FTDI_FT230X_Basic_UART_DO01HE8Q-if00-port0")
self.d.unsel()
self.d.seta(1)
self.d.setb(1)
if 0:
print('reset')
self.d.setb(0)
time.sleep(.1)
self.d.setb(1)
def preview(cmdbuf):
print('preview is', len(cmdbuf), 'bytes')
d = SPIDriver(
"/dev/serial/by-id/usb-FTDI_FT230X_Basic_UART_DO02C71A-if00-port0")
from bteve.gameduino_spidriver import GameduinoSPIDriver
gd = GameduinoSPIDriver(d)
gd.init()
gd.cc(cmdbuf)
gd.finish()
def on_refresh_gui(self):
self.grid.after(500, self.on_refresh_gui)
if self.port_prev != self.port_combo.get():
self.spi_driver = None
self.port_prev = self.port_combo.get()
if len(self.port_prev) > 0:
try:
self.spi_driver = SPIDriver(self.port_prev)
except serial.serialutil.SerialException:
pass
if self.spi_driver is not None:
self.spi_driver.getstatus()
self.ser_num.var.set(self.spi_driver.serial)
self.voltage.var.set("{0:.1f} V".format(self.spi_driver.voltage))
self.current.var.set("{0:.1f} mA".format(self.spi_driver.current))
self.deg_c.var.set("{0:.1f} °C".format(self.spi_driver.temp))
self.uptime.var.set(str(datetime.timedelta(seconds=self.spi_driver.uptime))) # https://stackoverflow.com/a/775095/101252
self.chk_ncs.var.set(not self.spi_driver.cs)
self.chk_a.var.set(self.spi_driver.a)
self.chk_b.var.set(self.spi_driver.b)
return
else:
self.ser_num.var.set('')
self.voltage.var.set('')
self.current.var.set('')
self.deg_c.var.set('')
self.uptime.var.set('')
self.chk_ncs.var.set(2)
self.chk_a.var.set(2)
self.chk_b.var.set(2)
self.miso.var.set('')
self.mosi.var.set('')
def __init__(self):
Gtk.Window.__init__(self, title="SPIDriver")
self.set_border_width(10)
self.sd = SPIDriver()
# help(self.sd)
hbox = Gtk.Box(spacing=6)
def pair(a, b):
r = Gtk.HBox(spacing=6)
r.pack_start(a, False, True, 0)
r.pack_end(b, False, True, 0)
return r
def label(s):
r = Gtk.Label()
r.set_text(s)
return r
def vbox(items):
r = Gtk.VBox(spacing=6)
[r.pack_start(i, True, True, 0) for i in items]
return r
def hbox(items):
r = Gtk.HBox(spacing=6)
[r.pack_start(i, False, True, 0) for i in items]
return r
def checkbutton(name, state, click):
r = Gtk.CheckButton(name)
r.set_active(state)
r.connect("clicked", click)
return r
def button(name, click):
r = Gtk.Button(name)
r.connect("clicked", click)
return r
self.label_voltage = Gtk.Label()
self.label_current = Gtk.Label()
self.label_temp = Gtk.Label()
self.tx = Gtk.Entry()
self.tx.set_max_length(2)
self.tx.set_width_chars(2)
self.rx = Gtk.Entry()
self.rx.set_width_chars(20)
self.add(vbox([
pair(label("Voltage"), self.label_voltage),
pair(label("Current"), self.label_current),
pair(label("Temp"), self.label_temp),
hbox([
checkbutton("CS", 1 - self.sd.cs, self.click_cs),
checkbutton("A", self.sd.a, self.click_a),
checkbutton("B", self.sd.b, self.click_b),
]),
pair(
self.tx,
button("Send", self.send)
),
pair(
self.rx,
button("Recv", self.click_a)
),
]))
self.refresh()
"""
self.add(hbox)
button = Gtk.Button.new_with_label("Click Me")
button.connect("clicked", self.on_click_me_clicked)
hbox.pack_start(button, True, True, 0)
button = Gtk.Button.new_with_mnemonic("_Open")
button.connect("clicked", self.on_open_clicked)
hbox.pack_start(button, True, True, 0)
button = Gtk.Button.new_with_mnemonic("_Close")
button.connect("clicked", self.on_close_clicked)
hbox.pack_start(button, True, True, 0)
hbox.pack_start(self.hbox([self.checkbutton("A"), self.checkbutton("b")]), True, True, 0)
label = Gtk.Label()
label.set_text("This is a left-justified label.\nWith multiple lines.")
label.set_justify(Gtk.Justification.LEFT)
hbox.pack_start(label, True, True, 0)
self.label_voltage = label
"""
GLib.timeout_add(1000, self.refresh)
class ButtonWindow(Gtk.Window):
def __init__(self):
Gtk.Window.__init__(self, title="SPIDriver")
self.set_border_width(10)
self.sd = SPIDriver()
# help(self.sd)
hbox = Gtk.Box(spacing=6)
def pair(a, b):
r = Gtk.HBox(spacing=6)
r.pack_start(a, False, True, 0)
r.pack_end(b, False, True, 0)
return r
def label(s):
r = Gtk.Label()
r.set_text(s)
return r
def vbox(items):
r = Gtk.VBox(spacing=6)
[r.pack_start(i, True, True, 0) for i in items]
return r
def hbox(items):
r = Gtk.HBox(spacing=6)
[r.pack_start(i, False, True, 0) for i in items]
return r
def checkbutton(name, state, click):
r = Gtk.CheckButton(name)
r.set_active(state)
r.connect("clicked", click)
return r
def button(name, click):
r = Gtk.Button(name)
r.connect("clicked", click)
return r
self.label_voltage = Gtk.Label()
self.label_current = Gtk.Label()
self.label_temp = Gtk.Label()
self.tx = Gtk.Entry()
self.tx.set_max_length(2)
self.tx.set_width_chars(2)
self.rx = Gtk.Entry()
self.rx.set_width_chars(20)
self.add(vbox([
pair(label("Voltage"), self.label_voltage),
pair(label("Current"), self.label_current),
pair(label("Temp"), self.label_temp),
hbox([
checkbutton("CS", 1 - self.sd.cs, self.click_cs),
checkbutton("A", self.sd.a, self.click_a),
checkbutton("B", self.sd.b, self.click_b),
]),
pair(
self.tx,
button("Send", self.send)
),
pair(
self.rx,
button("Recv", self.click_a)
),
]))
self.refresh()
"""
self.add(hbox)
button = Gtk.Button.new_with_label("Click Me")
button.connect("clicked", self.on_click_me_clicked)
hbox.pack_start(button, True, True, 0)
button = Gtk.Button.new_with_mnemonic("_Open")
button.connect("clicked", self.on_open_clicked)
hbox.pack_start(button, True, True, 0)
button = Gtk.Button.new_with_mnemonic("_Close")
button.connect("clicked", self.on_close_clicked)
hbox.pack_start(button, True, True, 0)
hbox.pack_start(self.hbox([self.checkbutton("A"), self.checkbutton("b")]), True, True, 0)
label = Gtk.Label()
label.set_text("This is a left-justified label.\nWith multiple lines.")
label.set_justify(Gtk.Justification.LEFT)
hbox.pack_start(label, True, True, 0)
self.label_voltage = label
"""
GLib.timeout_add(1000, self.refresh)
def refresh(self):
self.sd.getstatus()
self.label_voltage.set_text("%.2f V" % self.sd.voltage)
self.label_current.set_text("%d mA" % self.sd.current)
self.label_temp.set_text("%.1f C" % self.sd.temp)
return True
def click_cs(self, button):
print('CS state', button.get_state(), Gtk.StateType.ACTIVE)
[self.sd.unsel, self.sd.sel][ison(button)]()
def click_a(self, button):
self.sd.seta(int(button.get_state()))
def click_b(self, button):
self.sd.setb(int(button.get_state()))
def on_click_me_clicked(self, button):
print("\"Click me\" button was clicked")
def send(self, _):
b = self.tx.get_buffer()
print(b.get_text())
self.sd.write(struct.pack("B", int(b.get_text(), 16)))
b.delete_text(0, -1)
def on_open_clicked(self, button):
print("\"Open\" button was clicked")
def on_close_clicked(self, button):
print("Closing application")
Gtk.main_quit()
class Frame(wx.Frame):
def __init__(self):
self.sd = None
def widepair(a, b):
r = wx.BoxSizer(wx.HORIZONTAL)
r.Add(a, 1, wx.LEFT)
r.AddStretchSpacer(prop=1)
r.Add(b, 1, wx.RIGHT)
return r
def pair(a, b):
r = wx.BoxSizer(wx.HORIZONTAL)
r.Add(a, 1, wx.LEFT)
r.Add(b, 0, wx.RIGHT)
return r
def rpair(a, b):
r = wx.BoxSizer(wx.HORIZONTAL)
r.Add(a, 0, wx.LEFT)
r.Add(b, 1, wx.RIGHT)
return r
def label(s):
return wx.StaticText(self, label = s)
def hbox(items):
r = wx.BoxSizer(wx.HORIZONTAL)
[r.Add(i, 0, wx.EXPAND) for i in items]
return r
def hcenter(i):
r = wx.BoxSizer(wx.HORIZONTAL)
r.AddStretchSpacer(prop=1)
r.Add(i, 2, wx.CENTER)
r.AddStretchSpacer(prop=1)
return r
def vbox(items):
r = wx.BoxSizer(wx.VERTICAL)
[r.Add(i, 0, wx.EXPAND) for i in items]
return r
wx.Frame.__init__(self, None, -1, "SPIDriver")
self.label_serial = wx.StaticText(self, label = "-", style = wx.ALIGN_RIGHT)
self.label_voltage = wx.StaticText(self, label = "-", style = wx.ALIGN_RIGHT)
self.label_current = wx.StaticText(self, label = "-", style = wx.ALIGN_RIGHT)
self.label_temp = wx.StaticText(self, label = "-", style = wx.ALIGN_RIGHT)
self.label_uptime = wx.StaticText(self, label = "-", style = wx.ALIGN_RIGHT)
self.Bind(EVT_PING, self.refresh)
self.ckCS = wx.CheckBox(self, label = "CS")
self.ckA = wx.CheckBox(self, label = "A")
self.ckB = wx.CheckBox(self, label = "B")
self.ckCS.Bind(wx.EVT_CHECKBOX, self.check_cs)
self.ckA.Bind(wx.EVT_CHECKBOX, self.check_a)
self.ckB.Bind(wx.EVT_CHECKBOX, self.check_b)
ps = self.GetFont().GetPointSize()
fmodern = wx.Font(ps, wx.MODERN, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL)
def logger():
r = wx.TextCtrl(self, style=wx.TE_READONLY | wx.TE_RIGHT | wx.TE_DONTWRAP)
r.SetBackgroundColour(wx.Colour(224, 224, 224))
r.SetFont(fmodern)
return r
self.txMISO = logger()
self.txMOSI = logger()
self.txVal = HexTextCtrl(self, size=wx.DefaultSize, style=0)
self.txVal.SetMaxLength(2)
self.txVal.SetFont(wx.Font(14 * ps // 10,
wx.MODERN,
wx.FONTSTYLE_NORMAL,
wx.FONTWEIGHT_BOLD))
txButton = wx.Button(self, label = "Transfer")
txButton.Bind(wx.EVT_BUTTON, partial(self.transfer, self.txVal))
txButton.SetDefault()
self.allw = [self.ckCS, self.ckA, self.ckB, self.txVal, txButton, self.txMISO, self.txMOSI]
[w.Enable(False) for w in self.allw]
self.devs = self.devices()
cb = wx.ComboBox(self, choices = sorted(self.devs.keys()), style = wx.CB_READONLY)
cb.Bind(wx.EVT_COMBOBOX, self.choose_device)
vb = vbox([
label(""),
hcenter(cb),
label(""),
hcenter(pair(
vbox([
label("Serial"),
label("Voltage"),
label("Current"),
label("Temp."),
label("Running"),
]),
vbox([
self.label_serial,
self.label_voltage,
self.label_current,
self.label_temp,
self.label_uptime,
])
)),
label(""),
rpair(label("MISO"), self.txMISO),
rpair(label("MOSI"), self.txMOSI),
label(""),
hcenter(pair(self.ckCS, hbox([self.ckA, self.ckB]))),
label(""),
hcenter(pair(self.txVal, txButton)),
label(""),
])
self.SetSizerAndFit(vb)
self.SetAutoLayout(True)
if len(self.devs) > 0:
d1 = min(self.devs)
self.connect(self.devs[d1])
cb.SetValue(d1)
t = threading.Thread(target=ping_thr, args=(self, ))
t.setDaemon(True)
t.start()
def devices(self):
if sys.platform == 'darwin':
devdir = "/dev/"
pattern = "^tty.usbserial-(........)"
else:
devdir = "/dev/serial/by-id/"
pattern = "^usb-FTDI_FT230X_Basic_UART_(........)-"
if not os.access(devdir, os.R_OK):
return {}
devs = os.listdir(devdir)
def filter(d):
m = re.match(pattern, d)
if m:
return (m.group(1), devdir + d)
seldev = [filter(d) for d in devs]
return dict([d for d in seldev if d])
def connect(self, dev):
self.sd = SPIDriver(dev)
[w.Enable(True) for w in self.allw]
self.ckCS.SetValue(not self.sd.cs)
self.ckA.SetValue(self.sd.a)
self.ckB.SetValue(self.sd.b)
self.refresh(None)
def refresh(self, e):
if self.sd:
self.sd.getstatus()
self.label_serial.SetLabel(self.sd.serial)
self.label_voltage.SetLabel("%.2f V" % self.sd.voltage)
self.label_current.SetLabel("%d mA" % self.sd.current)
self.label_temp.SetLabel("%.1f C" % self.sd.temp)
days = self.sd.uptime // (24 * 3600)
rem = self.sd.uptime % (24 * 3600)
hh = rem // 3600
mm = (rem / 60) % 60
ss = rem % 60;
self.label_uptime.SetLabel("%d:%02d:%02d:%02d" % (days, hh, mm, ss))
def choose_device(self, e):
self.connect(self.devs[e.EventObject.GetValue()])
def check_cs(self, e):
if e.EventObject.GetValue():
self.sd.sel()
else:
self.sd.unsel()
def check_a(self, e):
self.sd.seta(e.EventObject.GetValue())
def check_b(self, e):
self.sd.setb(e.EventObject.GetValue())
def transfer(self, htc, e):
if htc.GetValue():
txb = int(htc.GetValue(), 16)
rxb = struct.unpack("B", self.sd.writeread(struct.pack("B", txb)))[0]
self.txMOSI.AppendText(" %02X" % txb)
self.txMISO.AppendText(" %02X" % rxb)
htc.ChangeValue("")
def image_to_data(self, image, rotation=0):
"""Generator function to convert a PIL image to 16-bit 565 RGB bytes."""
# NumPy is much faster at doing this. NumPy code provided by:
# Keith (https://www.blogger.com/profile/02555547344016007163)
pb = np.rot90(np.array(image.convert('RGB')), rotation // 90).astype('uint8')
result = np.zeros((self._width, self._height, 2), dtype=np.uint8)
result[..., [0]] = np.add(np.bitwise_and(pb[..., [0]], 0xF8), np.right_shift(pb[..., [1]], 5))
result[..., [1]] = np.add(np.bitwise_and(np.left_shift(pb[..., [1]], 3), 0xE0), np.right_shift(pb[..., [2]], 3))
return result.flatten().tolist()
if __name__ == '__main__':
try:
optlist, args = getopt.getopt(sys.argv[1:], "h:")
except getopt.GetoptError as reason:
print()
print('usage: st7789 [ -h device ] image...')
print()
print()
sys.exit(1)
optdict = dict(optlist)
st = ST7789(SPIDriver(optdict.get('-h', "/dev/ttyUSB0")))
st.start()
st.clear()
for a in args:
image = Image.open(a)
image = image.resize((240, 240))
st.display(image)
time.sleep(3)
#!/usr/bin/env python3
# coding=utf-8
import random
import time
from spidriver import SPIDriver
# print(hex(crc16xmodem(bytes([0xaa, 0xbb, 0xcc]), 0xffff)))
def rnd(n):
return random.randrange(n)
if __name__ == '__main__':
s = SPIDriver()
u = s.uptime
while s.uptime == u:
s.getstatus()
t0 = time.time()
d0 = s.uptime
while 1:
s.getstatus()
du = s.uptime - d0 # device uptime
tu = int(time.time() - t0) # true uptime
fastness = du - tu
print("%9d %.3f V %4d mA %.1f C %04x fast=%d" % (tu, s.voltage, s.current, s.temp, s.ccitt_crc, fastness))
time.sleep(10)
class GD(gameduino2.base.GD2):
def __init__(self, dev):
self.spi = SPIDriver(dev)
self.spi.setb(1)
if False:
self.spi.setb(0)
time.sleep(1)
self.spi.setb(1)
time.sleep(1)
self.coldstart()
t0 = time.time()
while self._rd32(gd3.REG_ID) != 0x7c:
assert (time.time() - t0) < 1.0, "No response - is GD attached?"
if 0:
time.sleep(1)
print("ID %8x" % self._rd32(gd3.REG_ID))
print("CMD_READ %8x" % self._rd32(gd3.REG_CMD_READ))
print("CMD_WRITE %8x" % self._rd32(gd3.REG_CMD_WRITE))
print("CMD_SPACE %8x" % self._rd32(gd3.REG_CMDB_SPACE))
while self._rd32(gd3.REG_ID) != 0x7c:
time.sleep(.1)
self.getspace()
self.stream()
def coldstart(self):
self.host_cmd(0x00) # Wake up
self.host_cmd(0x48) # int clock
self.host_cmd(0x68) # Core reset
time.sleep(.25)
def host_cmd(self, a, b = 0, c = 0):
self.spi.sel()
self.spi.write(bytes([a, b, c]))
self.spi.unsel()
def start(self, a):
self.spi.sel()
self.spi.write(bytes([
0xff & (a >> 16),
0xff & (a >> 8),
0xff & a]))
def _rd(self, a, n):
self.start(a)
r = self.spi.read(1 + n)
self.spi.unsel()
return r[1:]
def _rd32(self, a):
return struct.unpack("<I", self._rd(a, 4))[0]
def _wr32(self, a, v):
self.start(0x800000 | a)
self.spi.write(struct.pack("I", v))
self.spi.unsel()
def _wr(self, a, v):
self.start(0x800000 | a)
self.spi.write(v)
self.spi.unsel()
def getspace(self):
self.space = self._rd32(gd3.REG_CMDB_SPACE)
if self.space & 1:
raise CoprocessorException
def stream(self):
self.start(0x800000 | gd3.REG_CMDB_WRITE)
def unstream(self):
self.spi.unsel()
def reserve(self, n):
if self.space < n:
self.unstream()
while self.space < n:
self.getspace()
self.stream()
def c4(self, v):
'''
Write 32-bit value v to the command FIFO
'''
self.reserve(4)
self.spi.write(struct.pack("I", v))
self.space -= 4
def c(self, ss):
'''
Write s to the command FIFO
'''
for i in range(0, len(ss), 64):
s = ss[i:i + 64]
self.reserve(len(s))
self.spi.write(s)
self.space -= len(s)
def flush(self):
pass
def finish(self):
self.reserve(4092)
def is_idle(self):
self.unstream()
self.getspace()
self.stream()
return self.space == 4092
def rd32(self, a):
self.unstream()
r = self._rd32(a)
self.stream()
return r
def rd(self, a, n):
self.unstream()
r = self._rd(a, n)
self.stream()
return r
def wr(self, a, v):
self.unstream()
r = self._wr(a, v)
self.stream()
def result(self, n=1):
# Return the result field of the preceding command
self.finish()
self.unstream()
wp = self._rd32(gd3.REG_CMD_READ)
r = self._rd32(gd3.RAM_CMD + (4095 & (wp - 4 * n)))
self.stream()
return r
def setup_480x272(self):
b = 6
setup = [
(gd3.REG_OUTBITS, b * 73),
(gd3.REG_DITHER, 1),
(gd3.REG_GPIO, 0x83),
(gd3.REG_PCLK_POL, 1),
(gd3.REG_ROTATE, 0),
(gd3.REG_SWIZZLE, 3),
]
self.Clear()
self.swap()
for (a, v) in setup:
self.cmd_regwrite(a, v)
self.cmd_regwrite(gd3.REG_PCLK, 5) # Enable display
self.finish()
self.w = 480
self.h = 272
def setup_800x480(self):
b = 6
setup = [
(gd3.REG_OUTBITS, b * 73),
(gd3.REG_DITHER, 1),
(gd3.REG_GPIO, 0x83),
(gd3.REG_ROTATE, 0),
(gd3.REG_SWIZZLE, 3),
(gd3.REG_HCYCLE, 928),
(gd3.REG_HOFFSET, 88),
(gd3.REG_HSIZE, 800),
(gd3.REG_HSYNC0, 0),
(gd3.REG_HSYNC1, 48),
(gd3.REG_VCYCLE, 525),
(gd3.REG_VOFFSET, 32),
(gd3.REG_VSIZE, 480),
(gd3.REG_VSYNC0, 0),
(gd3.REG_VSYNC1, 3),
(gd3.REG_CSPREAD, 0),
(gd3.REG_PCLK_POL, 0),
]
for (a, v) in setup:
self.cmd_regwrite(a, v)
self.Clear()
self.swap()
self.finish()
self.cmd_regwrite(gd3.REG_PCLK, 2) # Enable display
self.w = 800
self.h = 480
def calibrate(self):
self.Clear()
self.cmd_text(240, 135, 29, gd3.OPT_CENTER, "Tap the dot")
self.cmd_calibrate(0)
self.cmd_dlstart()
def screenshot(self, dest):
REG_SCREENSHOT_EN = 0x302010 # Set to enable screenshot mode
REG_SCREENSHOT_Y = 0x302014 # Y line register
REG_SCREENSHOT_START = 0x302018 # Screenshot start trigger
REG_SCREENSHOT_BUSY = 0x3020e8 # Screenshot ready flags
REG_SCREENSHOT_READ = 0x302174 # Set to enable readout
RAM_SCREENSHOT = 0x3c2000 # Screenshot readout buffer
self.finish()
self.unstream()
self._wr32(REG_SCREENSHOT_EN, 1)
self._wr32(0x0030201c, 32)
self._wr32(REG_SCREENSHOT_READ, 1)
for ly in range(self.h):
self._wr32(REG_SCREENSHOT_Y, ly)
self._wr32(REG_SCREENSHOT_START, 1)
time.sleep(.002)
# while (self.raw_read(REG_SCREENSHOT_BUSY) | self.raw_read(REG_SCREENSHOT_BUSY + 4)): pass
while self._rd(REG_SCREENSHOT_BUSY, 8) != bytes(8):
pass
self._wr32(REG_SCREENSHOT_READ, 1)
bgra = self._rd(RAM_SCREENSHOT, 4 * self.w)
(b,g,r,a) = [bgra[i::4] for i in range(4)]
line = bytes(sum(zip(r,g,b), ()))
dest(line)
self._wr32(REG_SCREENSHOT_READ, 0)
self._wr32(REG_SCREENSHOT_EN, 0)
self.stream()
def screenshot_im(self):
self.ssbytes = b""
def appender(s):
self.ssbytes += s
self.screenshot(appender)
from PIL import Image
return Image.frombytes("RGB", (self.w, self.h), self.ssbytes)
class SPI:
def __init__(self, dev):
self.d = SPIDriver(dev)
self.d.unsel()
self.d.seta(1)
self.d.setb(1)
print('reset')
self.d.setb(0)
time.sleep(.1)
self.d.setb(1)
def transfer(self, wr, rd = 0):
self.d.sel()
self.d.write(wr)
r = self.d.read(rd)
self.d.unsel()
return r
import time
import sys
import getopt
if __name__ == '__main__':
try:
optlist, args = getopt.getopt(sys.argv[1:], "h:")
except getopt.GetoptError as reason:
print()
print('usage: iceprog [ -h device ] bitstream...')
print()
print()
sys.exit(1)
optdict = dict(optlist)
s = SPIDriver(optdict.get('-h', "/dev/ttyUSB0"))
s.sel() # Hold FPGA in reset
s.seta(0)
# Some primitives for the N25Q flash
def command(b):
s.unsel()
s.sel()
s.write(b)
def idcode():
command([0x9f])
return s.read(3)
def write_enable():
def pattern(n):
return [rnd(256) for i in range(n)]
if __name__ == '__main__':
try:
optlist, args = getopt.getopt(sys.argv[1:], "h:")
except getopt.GetoptError as reason:
print()
print('usage: st7735 [ -h device ] image...')
print()
print()
sys.exit(1)
optdict = dict(optlist)
s = SPIDriver(optdict.get('-h', "/dev/ttyUSB0"))
s.unsel()
while True:
s.sel() # start command
s.write(b'\x9f') # command 9F is READ JEDEC ID
ids = s.read(3)
(id1, id2, id3) = struct.unpack("BBB", ids)
print ("JEDEC ID: %02x %02x %02x" % (id1, id2, id3))
s.unsel() # end command
time.sleep(.02)
if id1 not in (0x00, 0xff):
break
for c in (0x66, 0x99):
s.sel() # start command
from spidriver import SPIDriver
s = SPIDriver("/dev/ttyUSB0") # change for your port
s.sel() # start command
s.write([0x9f]) # command 9F is READ JEDEC ID
print(list(s.read(3))) # read next 3 bytes
s.unsel() # end command
return "\n".join([hexline(s[i:i + 16]) for i in range(0, len(s), 16)])
if __name__ == '__main__':
try:
optlist, args = getopt.getopt(sys.argv[1:], "h:r:w:")
except getopt.GetoptError as reason:
print()
print('usage: flash [ -h device ] [ -r file ] [ -w file ]')
print()
print()
sys.exit(1)
optdict = dict(optlist)
s = SPIDriver(optdict.get('-h', "/dev/ttyUSB0"))
s.seta(0)
s.unsel()
# Some primitives for generic flash
def command(b):
s.unsel()
s.sel()
s.write(b)
def idcode():
command([0x9f])
return s.read(3)
def write_enable():
command([0x06])
import sys
import bteve as eve
import board
import busio
if sys.implementation.name == "circuitpython":
gd = eve.Gameduino()
else:
from spidriver import SPIDriver
gd = eve.Gameduino(SPIDriver(sys.argv[1]))
gd.init()
i2c = busio.I2C(board.SCL, board.SDA)
while not i2c.try_lock():
pass
def pot(a):
result = bytearray(1)
i2c.writeto_then_readfrom(a, bytes([0xff]), result)
return result[0]
while True:
gd.finish()
(r, g, b) = (pot(0x2a), pot(0x28), pot(0x2c))
gd.ClearColorRGB(r, g, b)
gd.Clear()
def gauge(x, bg, c):
gd.cmd_bgcolor(bg)
import random
import time
import sys
import array
from crc16pure import crc16xmodem
import spidriver
# print(hex(crc16xmodem(bytes([0xaa, 0xbb, 0xcc]), 0xffff)))
def rnd(n):
return random.randrange(n)
if __name__ == '__main__':
s = SPIDriver(sys.argv[1])
t1 = time.time() + float(sys.argv[2])
i = 0
random.seed(7)
while time.time() < t1:
expected = s.ccitt_crc
s.unsel()
l = 1 + rnd(100)
db = [rnd(256) for j in range(l)]
s.write(db)
expected = crc16xmodem(db, expected)
s.unsel()
db = [rnd(256) for j in range(64)]
r = list(array.array('B', s.writeread(db)))
expected = crc16xmodem(db, expected)
class SpiDriverGui:
"""
Setup main GUI window.
Main windows is a grid/table of widgets.
Data variable is attached to each tkinter widget e.g., self.ser_num.var.set('blah')
on_refresh_gui() will typically update each field.
"""
def __init__(self):
self.spi_driver = None # none yet.
self.grid = tkinter.Tk() # Root window is used as a grid or table.
self.grid.configure(padx=8, pady=8) # add padding around grid.
self.grid.title(os.path.basename(__file__)) # Display filename in title bar.
# region Compose GUI widgets.
row = 0 # row counter, used to add widgets to grid.
# region COM port combo.
tkinter.Label(self.grid, text='Port').grid(row=row, column=0)
comports = [port.device for port in serial.tools.list_ports.comports()]
self.port_combo = tkinter.ttk.Combobox(self.grid, values=comports, width=10)
self.port_combo.grid(row=row, column=1)
self.port_prev = None
if len(comports) > 0:
self.port_combo.current(len(comports)-1) # Select last entry.
row += 1
# endregion COM port combo.
# region Diagnostic fields
def create_display_parameter(str_name, row) -> tkinter.Entry:
lbl = tkinter.Label(self.grid, text=str_name)
lbl.grid(row=row, column=0)
string_var = tkinter.StringVar()
field = tkinter.Entry(self.grid, textvariable=string_var, state="readonly", width=12)
field.grid(row=row, column=1)
field.var = string_var # Bind the var to the Entry.
return field
self.ser_num = create_display_parameter('Serial', row); row += 1
self.voltage = create_display_parameter('Voltage', row); row += 1
self.current = create_display_parameter('Current', row); row += 1
self.deg_c = create_display_parameter('Temp', row); row += 1
self.uptime = create_display_parameter('Uptime', row); row += 1
self.miso = create_display_parameter('MISO', row); row += 1
self.mosi = create_display_parameter('MOSI', row); row += 1
# endregion Diagnostic fields
# region 3 checkboxes
# Add three checkboxes to the same row in the table.
# nCS is inverted (active low)
chk_frame = tkinter.Frame(self.grid)
v = tkinter.IntVar(); self.chk_ncs = tkinter.Checkbutton(chk_frame, text="nCS", variable=v, command=self.on_chk_ncs ); self.chk_ncs.pack(side=tkinter.LEFT); self.chk_ncs.var = v
v = tkinter.IntVar(); self.chk_a = tkinter.Checkbutton(chk_frame, text="A", variable=v, command=self.on_chk_a ); self.chk_a.pack(side=tkinter.LEFT); self.chk_a.var = v
v = tkinter.IntVar(); self.chk_b = tkinter.Checkbutton(chk_frame, text="B", variable=v, command=self.on_chk_b ); self.chk_b.pack(side=tkinter.LEFT); self.chk_b.var = v
chk_frame.grid(row=row, column=0, columnspan=2);
row += 1
# endregion 3 checkboxes
tkinter.Label(self.grid, text='Send bytes').grid(row=row, column=0)
v = tkinter.StringVar()
self.send_bytes = tkinter.Entry(self.grid, textvariable=v, width=12)
self.send_bytes.grid(row=row, column=1)
self.send_bytes.var = v
v.set('12 AB')
row += 1
self.btn_send = tkinter.Button(self.grid, text='Transfer', command = self.on_transfer); self.btn_send.grid(row=row, column=1)
#endregion Compose GUI widgets.
self.grid.after(500, self.on_refresh_gui) # Establish a refresh routine.
self.grid.mainloop() # launch GUI.
#region Event handlers (typically start with 'on_').
def on_chk_a(self):
self.spi_driver.seta(self.chk_a.var.get())
def on_chk_b(self):
self.spi_driver.setb(self.chk_b.var.get())
def on_chk_ncs(self):
self.spi_driver.sel() if self.chk_ncs.var.get() else self.spi_driver.unsel()
'''
Main refresh function used to update GUI widgets.
Called periodically using 'tkinter.after()'
'''
def on_refresh_gui(self):
self.grid.after(500, self.on_refresh_gui)
if self.port_prev != self.port_combo.get():
self.spi_driver = None
self.port_prev = self.port_combo.get()
if len(self.port_prev) > 0:
try:
self.spi_driver = SPIDriver(self.port_prev)
except serial.serialutil.SerialException:
pass
if self.spi_driver is not None:
self.spi_driver.getstatus()
self.ser_num.var.set(self.spi_driver.serial)
self.voltage.var.set("{0:.1f} V".format(self.spi_driver.voltage))
self.current.var.set("{0:.1f} mA".format(self.spi_driver.current))
self.deg_c.var.set("{0:.1f} °C".format(self.spi_driver.temp))
self.uptime.var.set(str(datetime.timedelta(seconds=self.spi_driver.uptime))) # https://stackoverflow.com/a/775095/101252
self.chk_ncs.var.set(not self.spi_driver.cs)
self.chk_a.var.set(self.spi_driver.a)
self.chk_b.var.set(self.spi_driver.b)
return
else:
self.ser_num.var.set('')
self.voltage.var.set('')
self.current.var.set('')
self.deg_c.var.set('')
self.uptime.var.set('')
self.chk_ncs.var.set(2)
self.chk_a.var.set(2)
self.chk_b.var.set(2)
self.miso.var.set('')
self.mosi.var.set('')
"""
Exchange MOSI & MISO data with SPI Driver hardware using writeread().
"""
def on_transfer(self):
# bytearray.fromhex will accept spaces between bytes.
# hexlify will create a string with a hexadecimal representation of the byte array.
tx = bytearray.fromhex(self.send_bytes.var.get())
self.mosi.var.set(binascii.hexlify(tx))
rx = self.spi_driver.writeread(tx)
self.miso.var.set(binascii.hexlify(rx))
import time
from spidriver import SPIDriver
def rnd(n):
return random.randrange(n)
def pattern(n):
return [rnd(256) for i in range(n)]
if __name__ == '__main__':
if len(sys.argv) > 1:
s = SPIDriver(sys.argv[1])
else:
s = SPIDriver()
# print(s)
# t1 = time.time() + float(sys.argv[2])
while True: # time.time() < t1:
for i in range(50):
random.choice([
lambda: s.seta(rnd(2)),
lambda: s.setb(rnd(2)),
lambda: s.sel(),
lambda: s.unsel(),
lambda: s.writeread(pattern(1 + rnd(1))),
# lambda: s.read(1 + rnd(12)),
# lambda: s.getstatus()
])()
class SPIDriverWindow(Gtk.Window):
def __init__(self):
Gtk.Window.__init__(self, title="SPIDriver")
self.set_border_width(10)
self.sd = SPIDriver()
def pair(a, b):
r = Gtk.HBox(spacing=6)
r.pack_start(a, False, True, 0)
r.pack_end(b, False, True, 0)
return r
def label(s):
r = Gtk.Label()
r.set_text(s)
return r
def vbox(items):
r = Gtk.VBox(spacing=6)
[r.pack_start(i, True, True, 0) for i in items]
return r
def hbox(items):
r = Gtk.HBox(spacing=6)
[r.pack_start(i, False, True, 0) for i in items]
return r
def checkbutton(name, state, click):
r = Gtk.CheckButton(name)
r.set_active(state)
r.connect("clicked", click)
return r
def button(name, click):
r = Gtk.Button(name)
r.connect("clicked", click)
return r
self.label_voltage = Gtk.Label()
self.label_current = Gtk.Label()
self.label_temp = Gtk.Label()
self.tx = Gtk.Entry()
self.tx.set_width_chars(20)
self.tx.connect('changed', self.edit)
self.rx = Gtk.Entry()
self.rx.set_width_chars(20)
self.rx.connect('button-press-event', lambda a, b: True)
self.rx.set_property('editable', False)
self.button_send = button("Send", self.send)
self.button_send.set_sensitive(False)
self.add(
vbox([
pair(label("Voltage"), self.label_voltage),
pair(label("Current"), self.label_current),
pair(label("Temp"), self.label_temp),
Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL),
hbox([
checkbutton("CS", 1 - self.sd.cs, self.click_cs),
checkbutton("A", self.sd.a, self.click_a),
checkbutton("B", self.sd.b, self.click_b),
]),
pair(self.tx, self.button_send),
pair(self.rx, button("Recv", self.recv)),
]))
self.refresh()
GLib.timeout_add(1000, self.refresh)
def refresh(self):
self.sd.getstatus()
self.label_voltage.set_text("%.2f V" % self.sd.voltage)
self.label_current.set_text("%d mA" % self.sd.current)
self.label_temp.set_text("%.1f C" % self.sd.temp)
return True
def click_cs(self, button):
[self.sd.unsel, self.sd.sel][ison(button)]()
def click_a(self, button):
self.sd.seta(ison(button))
def click_b(self, button):
self.sd.setb(ison(button))
def edit(self, _):
b = self.tx.get_buffer()
valid = all([ishex(w) for w in b.get_text().split()])
self.button_send.set_sensitive(valid)
def transfer(self, byte):
byte = struct.unpack("B", self.sd.writeread(struct.pack("B", byte)))[0]
txb = self.tx.get_buffer()
txb.delete_text(0, -1)
rxb = self.rx.get_buffer()
rxb.set_text(rxb.get_text()[-17:] + " %02x" % byte, -1)
def send(self, _):
b = self.tx.get_buffer()
for w in b.get_text().split():
self.transfer(int(w, 16))
def recv(self, _):
self.transfer(0xff)
#!/usr/bin/env python3
import sys
import colorsys
from spidriver import SPIDriver
if __name__ == '__main__':
s = SPIDriver(sys.argv[1])
L = 300
blanking = [0] * ((L + 31) // 32)
s.write(blanking + [0x80, 0x80, 0x80] * L + blanking)
rainbow = sum([colorsys.hsv_to_rgb(float(i) / L, 1, 1) for i in range(L)],
())
rainbow = [int(128 + 127 * v) for v in rainbow]
while True:
s.write(rainbow + blanking)
rainbow = rainbow[3:] + rainbow[:3]
def __init__(self):
Gtk.Window.__init__(self, title="SPIDriver")
self.set_border_width(10)
self.sd = SPIDriver()
def pair(a, b):
r = Gtk.HBox(spacing=6)
r.pack_start(a, False, True, 0)
r.pack_end(b, False, True, 0)
return r
def label(s):
r = Gtk.Label()
r.set_text(s)
return r
def vbox(items):
r = Gtk.VBox(spacing=6)
[r.pack_start(i, True, True, 0) for i in items]
return r
def hbox(items):
r = Gtk.HBox(spacing=6)
[r.pack_start(i, False, True, 0) for i in items]
return r
def checkbutton(name, state, click):
r = Gtk.CheckButton(name)
r.set_active(state)
r.connect("clicked", click)
return r
def button(name, click):
r = Gtk.Button(name)
r.connect("clicked", click)
return r
self.label_voltage = Gtk.Label()
self.label_current = Gtk.Label()
self.label_temp = Gtk.Label()
self.tx = Gtk.Entry()
self.tx.set_width_chars(20)
self.tx.connect('changed', self.edit)
self.rx = Gtk.Entry()
self.rx.set_width_chars(20)
self.rx.connect('button-press-event', lambda a, b: True)
self.rx.set_property('editable', False)
self.button_send = button("Send", self.send)
self.button_send.set_sensitive(False)
self.add(
vbox([
pair(label("Voltage"), self.label_voltage),
pair(label("Current"), self.label_current),
pair(label("Temp"), self.label_temp),
Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL),
hbox([
checkbutton("CS", 1 - self.sd.cs, self.click_cs),
checkbutton("A", self.sd.a, self.click_a),
checkbutton("B", self.sd.b, self.click_b),
]),
pair(self.tx, self.button_send),
pair(self.rx, button("Recv", self.recv)),
]))
self.refresh()
GLib.timeout_add(1000, self.refresh)
#!/usr/bin/env python3
# coding=utf-8
import sys
from Eve import Eve
from spidriver import SPIDriver
def align4(s):
return s + bytes(-len(s) & 3)
if __name__ == '__main__':
if len(sys.argv) > 1:
s = SPIDriver(sys.argv[1])
else:
s = SPIDriver()
e = Eve(s)
e.initialize()
e.cmd_setbitmap(0, e.RGB565, 480, 272)
e.Clear()
e.Begin(Eve.BITMAPS)
e.Vertex2f(0, 0)
e.swap()
e.finish()
for a in sys.argv[2:]:
e.cmd_loadimage(0, Eve.OPT_NODL)
e.c(align4(open(a, "rb").read()))
class GameduinoSPIDriver(gameduino.Gameduino):
def __init__(self):
self.d = SPIDriver(
"/dev/serial/by-id/usb-FTDI_FT230X_Basic_UART_DO01HE8Q-if00-port0")
self.d.unsel()
self.d.seta(1)
self.d.setb(1)
if 0:
print('reset')
self.d.setb(0)
time.sleep(.1)
self.d.setb(1)
def transfer(self, wr, rd=0):
self.d.sel()
self.d.write(wr)
r = self.d.read(rd)
self.d.unsel()
return r