remote.py 4.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146
  1. import array
  2. import StringIO
  3. import zlib
  4. import Image
  5. import struct
  6. import time
  7. import convert
  8. def pad4(s):
  9. while len(s) % 4:
  10. s += chr(0)
  11. return s
  12. import gameduino2.registers as reg
  13. import gameduino2.base
  14. class GD2Exception(Exception):
  15. pass
  16. class GD2(gameduino2.base.GD2):
  17. def __init__(self, transport):
  18. self.ramptr = 0
  19. self.wp = 0
  20. self.cc = StringIO.StringIO()
  21. self.transport = transport
  22. self.transport.reset()
  23. self.wr(reg.REG_GPIO, 0xff)
  24. self.wr32(reg.REG_HCYCLE, 525)
  25. self.wr32(reg.REG_HOFFSET, 43)
  26. self.wr32(reg.REG_HSIZE, 480)
  27. self.wr32(reg.REG_HSYNC0, 0)
  28. self.wr32(reg.REG_HSYNC1, 41)
  29. self.wr32(reg.REG_VCYCLE, 286)
  30. self.wr32(reg.REG_VOFFSET, 12)
  31. self.wr32(reg.REG_VSIZE, 272)
  32. self.wr32(reg.REG_VSYNC0, 0)
  33. self.wr32(reg.REG_VSYNC1, 10)
  34. self.wr32(reg.REG_CSPREAD, 1)
  35. self.wr32(reg.REG_DITHER, 1)
  36. self.wr32(reg.REG_PCLK_POL, 1)
  37. self.cmd_dlstart()
  38. self.Clear(1,1,1)
  39. self.Display()
  40. self.cmd_swap()
  41. self.cmd_regwrite(reg.REG_PCLK, 5)
  42. self.finish()
  43. def rdstr(self, a, n):
  44. return self.transport.rdstr(a, n)
  45. def wrstr(self, a, s):
  46. return self.transport.wrstr(a, s)
  47. def wr(self, a, v):
  48. """ Write a single byte ``v`` to address ``a``. """
  49. self.wrstr(a, chr(v))
  50. def rd(self, a):
  51. """ Read byte at address ``a`` """
  52. return struct.unpack("<B", self.rdstr(a, 1))[0]
  53. def rd16(self, a):
  54. return struct.unpack("<H", self.rdstr(a, 2))[0]
  55. def rd32(self, a):
  56. return struct.unpack("<L", self.rdstr(a, 4))[0]
  57. def wr16(self, a, v):
  58. """ Write 16-bit value ``v`` at to address ``a`` """
  59. self.wrstr(a, struct.pack("<H", v))
  60. def wr32(self, a, v):
  61. """ Write 32-bit value ``v`` at to address ``a`` """
  62. self.wrstr(a, struct.pack("<L", v))
  63. def command(self, cmd):
  64. assert (len(cmd) % 4) == 0
  65. while True:
  66. rp = self.rd16(reg.REG_CMD_READ)
  67. if rp & 3:
  68. raise GD2Exception, "At address %04X" % self.rd32(reg.RAM_CMD)
  69. fullness = (self.wp - rp) & 4095
  70. available = 4096 - 4 - fullness
  71. if min(1000, len(cmd)) <= available:
  72. break
  73. canwrite = min(available, len(cmd))
  74. if canwrite != len(cmd):
  75. self.command(cmd[:canwrite])
  76. return self.command(cmd[canwrite:])
  77. if (self.wp + len(cmd)) < 4096:
  78. self.wrstr(reg.RAM_CMD + self.wp, cmd)
  79. self.wp += len(cmd)
  80. else:
  81. rem = 4096 - self.wp
  82. self.wrstr(reg.RAM_CMD + self.wp, cmd[:rem])
  83. self.wrstr(reg.RAM_CMD, cmd[rem:])
  84. self.wp = len(cmd) - rem
  85. assert (self.wp % 4) == 0
  86. assert 0 <= self.wp < 4096
  87. self.wr16(reg.REG_CMD_WRITE, self.wp)
  88. def finish(self):
  89. c = self.cc.getvalue()
  90. self.cc = StringIO.StringIO()
  91. for i in range(0, len(c), 4096):
  92. res = self.command(c[i:i+4096])
  93. # self.v.waitidle()
  94. def c(self, cmdstr):
  95. self.cc.write(pad4(cmdstr))
  96. def load_image(self, im, dither = False, fmt = reg.ARGB1555, sampling = reg.NEAREST, zoom = 1):
  97. strides = {
  98. reg.L1 : lambda w: w / 8,
  99. reg.L4 : lambda w: w / 2,
  100. reg.L8 : lambda w: w,
  101. reg.RGB332 : lambda w: w,
  102. reg.ARGB2 : lambda w: w,
  103. reg.PALETTED : lambda w: w,
  104. }
  105. if fmt == reg.L1:
  106. i = Image.new(im.mode, ((im.size[0] + 7) & ~7, im.size[1]))
  107. i.paste(im, (0,0))
  108. im = i
  109. stride = strides.get(fmt, lambda w: 2 * w)(im.size[0])
  110. (_,da) = convert.convert(im, dither = dither, fmt = fmt)
  111. self.ramptr = (self.ramptr + 1) & ~1
  112. self.zload(self.ramptr, da.tostring())
  113. self.BitmapSize(sampling, reg.BORDER, reg.BORDER, min(511, zoom * im.size[0]), min(511, zoom * im.size[1]))
  114. self.BitmapSource(self.ramptr)
  115. self.BitmapLayout(fmt, stride, im.size[1])
  116. self.ramptr += len(da.tostring())
  117. def zload(self, dst, data):
  118. self.cmd_inflate(dst)
  119. c = zlib.compress(data)
  120. print len(data), len(c)
  121. self.c(pad4(c))