GD2.h 29 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037
  1. /*
  2. * Copyright (C) 2013-2015 by James Bowman <jamesb@excamera.com>
  3. * Gameduino 2 library for Arduino, Arduino Due, Raspberry Pi.
  4. *
  5. */
  6. #ifndef _GD2_H_INCLUDED
  7. #define _GD2_H_INCLUDED
  8. #if defined(RASPBERRY_PI) || defined(DUMPDEV)
  9. #include "wiring.h"
  10. #endif
  11. #if defined(RASPBERRY_PI)
  12. #define REPORT(VAR) fprintf(stderr, #VAR "=%d\n", (VAR))
  13. #else
  14. #define REPORT(VAR) (Serial.print(#VAR "="), Serial.println(VAR, DEC))
  15. #endif
  16. #include "Arduino.h"
  17. #include <stdarg.h>
  18. #define RGB(r, g, b) ((uint32_t)((((r) & 0xffL) << 16) | (((g) & 0xffL) << 8) | ((b) & 0xffL)))
  19. #define F8(x) (int((x) * 256L))
  20. #define F16(x) ((int32_t)((x) * 65536L))
  21. #define GD_CALIBRATE 1
  22. #define GD_TRIM 2
  23. #define GD_STORAGE 4
  24. #ifdef __SAM3X8E__
  25. #define __DUE__ 1
  26. #endif
  27. ////////////////////////////////////////////////////////////////////////
  28. // Decide if we want to compile in SDcard support
  29. //
  30. // For stock Arduino models: yes
  31. // Raspberry PI: no
  32. // Arduino Due: no
  33. //
  34. #if !defined(RASPBERRY_PI) && !defined(DUMPDEV)
  35. #define SDCARD 1
  36. #else
  37. #define SDCARD 0
  38. #endif
  39. #if defined(__DUE__)
  40. #define MOSI 11
  41. #define MISO 12
  42. #define SCK 13 // B.27
  43. class ASPI_t {
  44. public:
  45. void begin(void) {
  46. pinMode(MOSI, OUTPUT);
  47. pinMode(MISO, INPUT);
  48. pinMode(SCK, OUTPUT);
  49. digitalWrite(SCK, 0);
  50. // PIOB->PIO_PER = PIO_PB27;
  51. // PIOB->PIO_CODR = PIO_PB27;
  52. // PIOB->PIO_PUDR = PIO_PB27;
  53. }
  54. byte transfer(byte x ) {
  55. byte r = 0;
  56. for (byte i = 8; i; i--) {
  57. if (x & 0x80)
  58. PIOD->PIO_SODR = PIO_PD7;
  59. else
  60. PIOD->PIO_CODR = PIO_PD7;
  61. // digitalWrite(MOSI, (x >> 7) & 1);
  62. x <<= 1;
  63. // digitalWrite(SCK, 1);
  64. PIOB->PIO_SODR = PIO_PB27;
  65. r <<= 1;
  66. r |= digitalRead(MISO);
  67. // digitalWrite(SCK, 0);
  68. PIOB->PIO_CODR = PIO_PB27;
  69. }
  70. return r;
  71. }
  72. };
  73. static class ASPI_t ASPI;
  74. #define SPI ASPI
  75. #endif
  76. #if SDCARD
  77. #define VERBOSE 0
  78. struct dirent {
  79. char name[8];
  80. char ext[3];
  81. byte attribute;
  82. byte reserved[8];
  83. uint16_t cluster_hi; // FAT32 only
  84. uint16_t time;
  85. uint16_t date;
  86. uint16_t cluster;
  87. uint32_t size;
  88. };
  89. // https://www.sdcard.org/downloads/pls/simplified_specs/Part_1_Physical_Layer_Simplified_Specification_Ver_3.01_Final_100518.pdf
  90. // page 22
  91. // http://mac6.ma.psu.edu/space2008/RockSat/microController/sdcard_appnote_foust.pdf
  92. // http://elm-chan.org/docs/mmc/mmc_e.html
  93. // http://www.pjrc.com/tech/8051/ide/fat32.html
  94. #define FAT16 0
  95. #define FAT32 1
  96. class sdcard {
  97. public:
  98. void sel() {
  99. digitalWrite(pin, LOW);
  100. delay(1);
  101. }
  102. void desel() {
  103. digitalWrite(pin, HIGH);
  104. SPI.transfer(0xff); // force DO release
  105. }
  106. void sd_delay(byte n) {
  107. while (n--)
  108. SPI.transfer(0xff);
  109. }
  110. void cmd(byte cmd, uint32_t lba = 0, uint8_t crc = 0x95) {
  111. #if VERBOSE
  112. Serial.print("cmd ");
  113. Serial.print(cmd, DEC);
  114. Serial.print(" ");
  115. Serial.print(lba, HEX);
  116. Serial.println();
  117. #endif
  118. sel();
  119. SPI.transfer(0xff);
  120. SPI.transfer(0x40 | cmd);
  121. SPI.transfer(0xff & (lba >> 24));
  122. SPI.transfer(0xff & (lba >> 16));
  123. SPI.transfer(0xff & (lba >> 8));
  124. SPI.transfer(0xff & (lba));
  125. SPI.transfer(crc);
  126. SPI.transfer(0xff);
  127. }
  128. byte R1() { // read response R1
  129. byte r;
  130. while ((r = SPI.transfer(0xff)) & 0x80)
  131. ;
  132. desel();
  133. SPI.transfer(0xff); // trailing byte
  134. return r;
  135. }
  136. byte sdR3(uint32_t &ocr) { // read response R3
  137. uint32_t r;
  138. while ((r = SPI.transfer(0xff)) & 0x80)
  139. ;
  140. for (byte i = 4; i; i--)
  141. ocr = (ocr << 8) | SPI.transfer(0xff);
  142. SPI.transfer(0xff); // trailing byte
  143. desel();
  144. return r;
  145. }
  146. byte sdR7() { // read response R3
  147. uint32_t r;
  148. while ((r = SPI.transfer(0xff)) & 0x80)
  149. ;
  150. for (byte i = 4; i; i--)
  151. // Serial.println(SPI.transfer(0xff), HEX);
  152. SPI.transfer(0xff);
  153. desel();
  154. return r;
  155. }
  156. void appcmd(byte cc, uint32_t lba = 0) {
  157. cmd(55); R1();
  158. cmd(cc, lba);
  159. }
  160. void begin(byte p) {
  161. byte type_code;
  162. byte sdhc;
  163. pin = p;
  164. pinMode(pin, OUTPUT);
  165. #if !defined(__DUE__)
  166. SPI.setClockDivider(SPI_CLOCK_DIV64);
  167. #endif
  168. desel();
  169. delay(10); // wait for boot
  170. sd_delay(10); // deselected, 80 pulses
  171. // Tty.printf("Attempting card reset... ");
  172. // attempt reset
  173. byte r1;
  174. int attempts = 0;
  175. do { // reset, enter idle
  176. cmd(0);
  177. while ((r1 = SPI.transfer(0xff)) & 0x80)
  178. if (++attempts == 1000)
  179. goto finished;
  180. desel();
  181. SPI.transfer(0xff); // trailing byte
  182. } while (r1 != 1);
  183. // Tty.printf("reset ok\n");
  184. sdhc = 0;
  185. cmd(8, 0x1aa, 0x87);
  186. r1 = sdR7();
  187. sdhc = (r1 == 1);
  188. // Tty.printf("card %s SDHC\n", sdhc ? "is" : "is not");
  189. // Tty.printf("Sending card init command... ");
  190. while (1) {
  191. appcmd(41, sdhc ? (1UL << 30) : 0); // card init
  192. r1 = R1();
  193. if ((r1 & 1) == 0)
  194. break;
  195. delay(100);
  196. }
  197. // Tty.printf("OK\n");
  198. if (sdhc) {
  199. cmd(58);
  200. uint32_t OCR = 0;
  201. sdR3(OCR);
  202. ccs = 1UL & (OCR >> 30);
  203. // Tty.printf("OCR register is %#010lx\n", long(OCR));
  204. } else {
  205. ccs = 0;
  206. }
  207. // REPORT(ccs);
  208. type_code = rd(0x1be + 0x4);
  209. switch (type_code) {
  210. default:
  211. type = FAT16;
  212. break;
  213. case 0x0b:
  214. case 0x0c:
  215. type = FAT32;
  216. break;
  217. }
  218. // REPORT(type_code);
  219. #if VERBOSE
  220. Serial.print("Type ");
  221. Serial.print(type_code, HEX);
  222. Serial.print(" so FAT");
  223. Serial.println((type == FAT16) ? 16 : 32, DEC);
  224. #endif
  225. o_partition = 512L * rd4(0x1be + 0x8);
  226. sectors_per_cluster = rd(o_partition + 0xd);
  227. reserved_sectors = rd2(o_partition + 0xe);
  228. cluster_size = 512L * sectors_per_cluster;
  229. // REPORT(sectors_per_cluster);
  230. // Tty.printf("Bytes per sector: %d\n", rd2(o_partition + 0xb));
  231. // Tty.printf("Sectors per cluster: %d\n", sectors_per_cluster);
  232. if (type == FAT16) {
  233. max_root_dir_entries = rd2(o_partition + 0x11);
  234. sectors_per_fat = rd2(o_partition + 0x16);
  235. o_fat = o_partition + 512L * reserved_sectors;
  236. o_root = o_fat + (2 * 512L * sectors_per_fat);
  237. // data area starts with cluster 2, so offset it here
  238. o_data = o_root + (max_root_dir_entries * 32L) - (2L * cluster_size);
  239. } else {
  240. uint32_t sectors_per_fat = rd4(o_partition + 0x24);
  241. root_dir_first_cluster = rd4(o_partition + 0x2c);
  242. uint32_t fat_begin_lba = (o_partition >> 9) + reserved_sectors;
  243. uint32_t cluster_begin_lba = (o_partition >> 9) + reserved_sectors + (2 * sectors_per_fat);
  244. o_fat = 512L * fat_begin_lba;
  245. o_root = (512L * (cluster_begin_lba + (root_dir_first_cluster - 2) * sectors_per_cluster));
  246. o_data = (512L * (cluster_begin_lba - 2 * sectors_per_cluster));
  247. }
  248. finished:
  249. // Serial.println("finished");
  250. ;
  251. #if !defined(__DUE__)
  252. SPI.setClockDivider(SPI_CLOCK_DIV2);
  253. SPSR = (1 << SPI2X);
  254. #endif
  255. }
  256. void cmd17(uint32_t off) {
  257. if (ccs)
  258. cmd(17, off >> 9);
  259. else
  260. cmd(17, off & ~511L);
  261. R1();
  262. sel();
  263. while (SPI.transfer(0xff) != 0xfe)
  264. ;
  265. }
  266. void rdn(byte *d, uint32_t off, uint16_t n) {
  267. cmd17(off);
  268. uint16_t i;
  269. uint16_t bo = (off & 511);
  270. for (i = 0; i < bo; i++)
  271. SPI.transfer(0xff);
  272. for (i = 0; i < n; i++)
  273. *d++ = SPI.transfer(0xff);
  274. for (i = 0; i < (514 - bo - n); i++)
  275. SPI.transfer(0xff);
  276. desel();
  277. }
  278. uint32_t rd4(uint32_t off) {
  279. uint32_t r;
  280. rdn((byte*)&r, off, sizeof(r));
  281. return r;
  282. }
  283. uint16_t rd2(uint32_t off) {
  284. uint16_t r;
  285. rdn((byte*)&r, off, sizeof(r));
  286. return r;
  287. }
  288. byte rd(uint32_t off) {
  289. byte r;
  290. rdn((byte*)&r, off, sizeof(r));
  291. return r;
  292. }
  293. byte pin;
  294. byte ccs;
  295. byte type;
  296. uint16_t sectors_per_cluster;
  297. uint16_t reserved_sectors;
  298. uint16_t max_root_dir_entries;
  299. uint16_t sectors_per_fat;
  300. uint16_t cluster_size;
  301. uint32_t root_dir_first_cluster;
  302. // These are all linear addresses, hence the o_ prefix
  303. uint32_t o_partition;
  304. uint32_t o_fat;
  305. uint32_t o_root;
  306. uint32_t o_data;
  307. };
  308. static void dos83(byte dst[11], const char *ps)
  309. {
  310. byte i = 0;
  311. while (*ps) {
  312. if (*ps != '.')
  313. dst[i++] = toupper(*ps);
  314. else {
  315. while (i < 8)
  316. dst[i++] = ' ';
  317. }
  318. ps++;
  319. }
  320. while (i < 11)
  321. dst[i++] = ' ';
  322. }
  323. #else
  324. class sdcard {
  325. public:
  326. void begin(int p) {};
  327. };
  328. #endif
  329. ////////////////////////////////////////////////////////////////////////
  330. class GDClass {
  331. public:
  332. void begin(uint8_t options = (GD_CALIBRATE | GD_TRIM | GD_STORAGE));
  333. uint16_t random();
  334. uint16_t random(uint16_t n);
  335. void seed(uint16_t n);
  336. int16_t rsin(int16_t r, uint16_t th);
  337. int16_t rcos(int16_t r, uint16_t th);
  338. void polar(int &x, int &y, int16_t r, uint16_t th);
  339. uint16_t atan2(int16_t y, int16_t x);
  340. void copy(const PROGMEM uint8_t *src, int count);
  341. void copyram(byte *src, int count);
  342. void self_calibrate(void);
  343. void swap(void);
  344. void flush(void);
  345. void finish(void);
  346. void play(uint8_t instrument, uint8_t note = 0);
  347. void sample(uint32_t start, uint32_t len, uint16_t freq, uint16_t format, int loop = 0);
  348. void get_inputs(void);
  349. void get_accel(int &x, int &y, int &z);
  350. struct {
  351. uint16_t track_tag;
  352. uint16_t track_val;
  353. uint16_t rz;
  354. uint16_t __dummy_1;
  355. int16_t y;
  356. int16_t x;
  357. int16_t tag_y;
  358. int16_t tag_x;
  359. uint8_t tag;
  360. uint8_t ptag;
  361. } inputs;
  362. void AlphaFunc(byte func, byte ref);
  363. void Begin(byte prim);
  364. void BitmapHandle(byte handle);
  365. void BitmapLayout(byte format, uint16_t linestride, uint16_t height);
  366. void BitmapSize(byte filter, byte wrapx, byte wrapy, uint16_t width, uint16_t height);
  367. void BitmapSource(uint32_t addr);
  368. void BitmapTransformA(int32_t a);
  369. void BitmapTransformB(int32_t b);
  370. void BitmapTransformC(int32_t c);
  371. void BitmapTransformD(int32_t d);
  372. void BitmapTransformE(int32_t e);
  373. void BitmapTransformF(int32_t f);
  374. void BlendFunc(byte src, byte dst);
  375. void Call(uint16_t dest);
  376. void Cell(byte cell);
  377. void ClearColorA(byte alpha);
  378. void ClearColorRGB(byte red, byte green, byte blue);
  379. void ClearColorRGB(uint32_t rgb);
  380. void Clear(byte c, byte s, byte t);
  381. void Clear(void);
  382. void ClearStencil(byte s);
  383. void ClearTag(byte s);
  384. void ColorA(byte alpha);
  385. void ColorMask(byte r, byte g, byte b, byte a);
  386. void ColorRGB(byte red, byte green, byte blue);
  387. void ColorRGB(uint32_t rgb);
  388. void Display(void);
  389. void End(void);
  390. void Jump(uint16_t dest);
  391. void LineWidth(uint16_t width);
  392. void Macro(byte m);
  393. void PointSize(uint16_t size);
  394. void RestoreContext(void);
  395. void Return(void);
  396. void SaveContext(void);
  397. void ScissorSize(uint16_t width, uint16_t height);
  398. void ScissorXY(uint16_t x, uint16_t y);
  399. void StencilFunc(byte func, byte ref, byte mask);
  400. void StencilMask(byte mask);
  401. void StencilOp(byte sfail, byte spass);
  402. void TagMask(byte mask);
  403. void Tag(byte s);
  404. void Vertex2f(int16_t x, int16_t y);
  405. void Vertex2ii(uint16_t x, uint16_t y, byte handle = 0, byte cell = 0);
  406. // Higher-level graphics commands
  407. void cmd_append(uint32_t ptr, uint32_t num);
  408. void cmd_bgcolor(uint32_t c);
  409. void cmd_button(int16_t x, int16_t y, uint16_t w, uint16_t h, byte font, uint16_t options, const char *s);
  410. void cmd_calibrate(void);
  411. void cmd_clock(int16_t x, int16_t y, int16_t r, uint16_t options, uint16_t h, uint16_t m, uint16_t s, uint16_t ms);
  412. void cmd_coldstart(void);
  413. void cmd_dial(int16_t x, int16_t y, int16_t r, uint16_t options, uint16_t val);
  414. void cmd_dlstart(void);
  415. void cmd_fgcolor(uint32_t c);
  416. void cmd_gauge(int16_t x, int16_t y, int16_t r, uint16_t options, uint16_t major, uint16_t minor, uint16_t val, uint16_t range);
  417. void cmd_getmatrix(void);
  418. void cmd_getprops(uint32_t &ptr, uint32_t &w, uint32_t &h);
  419. void cmd_getptr(void);
  420. void cmd_gradcolor(uint32_t c);
  421. void cmd_gradient(int16_t x0, int16_t y0, uint32_t rgb0, int16_t x1, int16_t y1, uint32_t rgb1);
  422. void cmd_inflate(uint32_t ptr);
  423. void cmd_interrupt(uint32_t ms);
  424. void cmd_keys(int16_t x, int16_t y, int16_t w, int16_t h, byte font, uint16_t options, const char*s);
  425. void cmd_loadidentity(void);
  426. void cmd_loadimage(uint32_t ptr, int32_t options);
  427. void cmd_memcpy(uint32_t dest, uint32_t src, uint32_t num);
  428. void cmd_memset(uint32_t ptr, byte value, uint32_t num);
  429. uint32_t cmd_memcrc(uint32_t ptr, uint32_t num);
  430. void cmd_memwrite(uint32_t ptr, uint32_t num);
  431. void cmd_regwrite(uint32_t ptr, uint32_t val);
  432. void cmd_number(int16_t x, int16_t y, byte font, uint16_t options, uint32_t n);
  433. void cmd_progress(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t options, uint16_t val, uint16_t range);
  434. void cmd_regread(uint32_t ptr);
  435. void cmd_rotate(int32_t a);
  436. void cmd_scale(int32_t sx, int32_t sy);
  437. void cmd_screensaver(void);
  438. void cmd_scrollbar(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t options, uint16_t val, uint16_t size, uint16_t range);
  439. void cmd_setfont(byte font, uint32_t ptr);
  440. void cmd_setmatrix(void);
  441. void cmd_sketch(int16_t x, int16_t y, uint16_t w, uint16_t h, uint32_t ptr, uint16_t format);
  442. void cmd_slider(int16_t x, int16_t y, uint16_t w, uint16_t h, uint16_t options, uint16_t val, uint16_t range);
  443. void cmd_snapshot(uint32_t ptr);
  444. void cmd_spinner(int16_t x, int16_t y, byte style, byte scale);
  445. void cmd_stop(void);
  446. void cmd_swap(void);
  447. void cmd_text(int16_t x, int16_t y, byte font, uint16_t options, const char *s);
  448. void cmd_toggle(int16_t x, int16_t y, int16_t w, byte font, uint16_t options, uint16_t state, const char *s);
  449. void cmd_track(int16_t x, int16_t y, uint16_t w, uint16_t h, byte tag);
  450. void cmd_translate(int32_t tx, int32_t ty);
  451. byte rd(uint32_t addr);
  452. void wr(uint32_t addr, uint8_t v);
  453. uint16_t rd16(uint32_t addr);
  454. void wr16(uint32_t addr, uint16_t v);
  455. uint32_t rd32(uint32_t addr);
  456. void wr32(uint32_t addr, uint32_t v);
  457. void wr_n(uint32_t addr, byte *src, uint32_t n);
  458. void cmd32(uint32_t b);
  459. void bulkrd(uint32_t a);
  460. void resume(void);
  461. void __end(void);
  462. void reset(void);
  463. void dumpscreen(void);
  464. byte load(const char *filename, void (*progress)(long, long) = NULL);
  465. void safeload(const char *filename);
  466. void alert(const char *message);
  467. sdcard SD;
  468. void storage(void);
  469. void tune(void);
  470. private:
  471. static void cFFFFFF(byte v);
  472. static void cI(uint32_t);
  473. static void ci(int32_t);
  474. static void cH(uint16_t);
  475. static void ch(int16_t);
  476. static void cs(const char *);
  477. static void fmtcmd(const char *fmt, ...);
  478. static void align(byte n);
  479. void cmdbyte(uint8_t b);
  480. uint32_t measure_freq(void);
  481. uint32_t rseed;
  482. };
  483. extern GDClass GD;
  484. extern byte ft8xx_model;
  485. #if SDCARD
  486. class Reader {
  487. public:
  488. int openfile(const char *filename) {
  489. int i = 0;
  490. byte dosname[11];
  491. dirent de;
  492. dos83(dosname, filename);
  493. do {
  494. GD.SD.rdn((byte*)&de, GD.SD.o_root + i * 32, sizeof(de));
  495. // Serial.println(de.name);
  496. if (0 == memcmp(de.name, dosname, 11)) {
  497. begin(de);
  498. return 1;
  499. }
  500. i++;
  501. } while (de.name[0]);
  502. return 0;
  503. }
  504. void begin(dirent &de) {
  505. size = de.size;
  506. cluster = de.cluster;
  507. if (GD.SD.type == FAT32)
  508. cluster |= ((long)de.cluster_hi << 16);
  509. sector = 0;
  510. offset = 0;
  511. }
  512. void nextcluster() {
  513. if (GD.SD.type == FAT16)
  514. cluster = GD.SD.rd2(GD.SD.o_fat + 2 * cluster);
  515. else
  516. cluster = GD.SD.rd4(GD.SD.o_fat + 4 * cluster);
  517. #if VERBOSE
  518. Serial.print("nextcluster=");
  519. Serial.println(cluster, DEC);
  520. #endif
  521. }
  522. void skipcluster() {
  523. nextcluster();
  524. offset += GD.SD.cluster_size;
  525. }
  526. void skipsector() {
  527. if (sector == GD.SD.sectors_per_cluster) {
  528. sector = 0;
  529. nextcluster();
  530. }
  531. sector++;
  532. offset += 512;
  533. }
  534. void seek(uint32_t o) {
  535. while (offset < o) {
  536. if ((sector == GD.SD.sectors_per_cluster) && ((o - offset) > (long)GD.SD.cluster_size))
  537. skipcluster();
  538. else
  539. skipsector();
  540. }
  541. }
  542. void readsector() {
  543. if (sector == GD.SD.sectors_per_cluster) {
  544. sector = 0;
  545. nextcluster();
  546. }
  547. uint32_t off = GD.SD.o_data + ((long)GD.SD.cluster_size * cluster) + (512L * sector);
  548. #if VERBOSE
  549. Serial.print("off=0x");
  550. Serial.println(off, HEX);
  551. #endif
  552. GD.SD.cmd17(off & ~511L);
  553. // Serial.println(2 * (micros() - t0), DEC);
  554. sector++;
  555. offset += 512;
  556. }
  557. void readsector(byte *dst) {
  558. readsector();
  559. for (int i = 0; i < 64; i++) {
  560. *dst++ = SPI.transfer(0xff);
  561. *dst++ = SPI.transfer(0xff);
  562. *dst++ = SPI.transfer(0xff);
  563. *dst++ = SPI.transfer(0xff);
  564. *dst++ = SPI.transfer(0xff);
  565. *dst++ = SPI.transfer(0xff);
  566. *dst++ = SPI.transfer(0xff);
  567. *dst++ = SPI.transfer(0xff);
  568. }
  569. SPI.transfer(0xff); // consume CRC
  570. SPI.transfer(0xff);
  571. GD.SD.desel();
  572. }
  573. uint32_t cluster;
  574. uint32_t offset;
  575. uint32_t size;
  576. byte sector;
  577. };
  578. #endif
  579. typedef struct {
  580. byte handle;
  581. uint16_t w, h;
  582. uint16_t size;
  583. } shape_t;
  584. // Convert degrees to Furmans
  585. #define DEGREES(n) ((65536UL * (n)) / 360)
  586. #define NEVER 0
  587. #define LESS 1
  588. #define LEQUAL 2
  589. #define GREATER 3
  590. #define GEQUAL 4
  591. #define EQUAL 5
  592. #define NOTEQUAL 6
  593. #define ALWAYS 7
  594. #define ARGB1555 0
  595. #define L1 1
  596. #define L4 2
  597. #define L8 3
  598. #define RGB332 4
  599. #define ARGB2 5
  600. #define ARGB4 6
  601. #define RGB565 7
  602. #define PALETTED 8
  603. #define TEXT8X8 9
  604. #define TEXTVGA 10
  605. #define BARGRAPH 11
  606. #define NEAREST 0
  607. #define BILINEAR 1
  608. #define BORDER 0
  609. #define REPEAT 1
  610. #define KEEP 1
  611. #define REPLACE 2
  612. #define INCR 3
  613. #define DECR 4
  614. #define INVERT 5
  615. #define DLSWAP_DONE 0
  616. #define DLSWAP_LINE 1
  617. #define DLSWAP_FRAME 2
  618. #define INT_SWAP 1
  619. #define INT_TOUCH 2
  620. #define INT_TAG 4
  621. #define INT_SOUND 8
  622. #define INT_PLAYBACK 16
  623. #define INT_CMDEMPTY 32
  624. #define INT_CMDFLAG 64
  625. #define INT_CONVCOMPLETE 128
  626. #define TOUCHMODE_OFF 0
  627. #define TOUCHMODE_ONESHOT 1
  628. #define TOUCHMODE_FRAME 2
  629. #define TOUCHMODE_CONTINUOUS 3
  630. #define ZERO 0
  631. #define ONE 1
  632. #define SRC_ALPHA 2
  633. #define DST_ALPHA 3
  634. #define ONE_MINUS_SRC_ALPHA 4
  635. #define ONE_MINUS_DST_ALPHA 5
  636. #define BITMAPS 1
  637. #define POINTS 2
  638. #define LINES 3
  639. #define LINE_STRIP 4
  640. #define EDGE_STRIP_R 5
  641. #define EDGE_STRIP_L 6
  642. #define EDGE_STRIP_A 7
  643. #define EDGE_STRIP_B 8
  644. #define RECTS 9
  645. #define OPT_MONO 1
  646. #define OPT_NODL 2
  647. #define OPT_FLAT 256
  648. #define OPT_CENTERX 512
  649. #define OPT_CENTERY 1024
  650. #define OPT_CENTER (OPT_CENTERX | OPT_CENTERY)
  651. #define OPT_NOBACK 4096
  652. #define OPT_NOTICKS 8192
  653. #define OPT_NOHM 16384
  654. #define OPT_NOPOINTER 16384
  655. #define OPT_NOSECS 32768
  656. #define OPT_NOHANDS 49152
  657. #define OPT_RIGHTX 2048
  658. #define OPT_SIGNED 256
  659. #define LINEAR_SAMPLES 0
  660. #define ULAW_SAMPLES 1
  661. #define ADPCM_SAMPLES 2
  662. // 'instrument' argument to GD.play()
  663. #define SILENCE 0x00
  664. #define SQUAREWAVE 0x01
  665. #define SINEWAVE 0x02
  666. #define SAWTOOTH 0x03
  667. #define TRIANGLE 0x04
  668. #define BEEPING 0x05
  669. #define ALARM 0x06
  670. #define WARBLE 0x07
  671. #define CAROUSEL 0x08
  672. #define PIPS(n) (0x0f + (n))
  673. #define HARP 0x40
  674. #define XYLOPHONE 0x41
  675. #define TUBA 0x42
  676. #define GLOCKENSPIEL 0x43
  677. #define ORGAN 0x44
  678. #define TRUMPET 0x45
  679. #define PIANO 0x46
  680. #define CHIMES 0x47
  681. #define MUSICBOX 0x48
  682. #define BELL 0x49
  683. #define CLICK 0x50
  684. #define SWITCH 0x51
  685. #define COWBELL 0x52
  686. #define NOTCH 0x53
  687. #define HIHAT 0x54
  688. #define KICKDRUM 0x55
  689. #define POP 0x56
  690. #define CLACK 0x57
  691. #define CHACK 0x58
  692. #define MUTE 0x60
  693. #define UNMUTE 0x61
  694. #define RAM_PAL 1056768UL
  695. #define RAM_CMD (ft8xx_model ? 0x308000UL : 0x108000UL)
  696. #define RAM_DL (ft8xx_model ? 0x300000UL : 0x100000UL)
  697. #define REG_CLOCK (ft8xx_model ? 0x302008UL : 0x102408UL)
  698. #define REG_CMD_DL (ft8xx_model ? 0x302100UL : 0x1024ecUL)
  699. #define REG_CMD_READ (ft8xx_model ? 0x3020f8UL : 0x1024e4UL)
  700. #define REG_CMD_WRITE (ft8xx_model ? 0x3020fcUL : 0x1024e8UL)
  701. #define REG_CPURESET (ft8xx_model ? 0x302020UL : 0x10241cUL)
  702. #define REG_CSPREAD (ft8xx_model ? 0x302068UL : 0x102464UL)
  703. #define REG_DITHER (ft8xx_model ? 0x302060UL : 0x10245cUL)
  704. #define REG_DLSWAP (ft8xx_model ? 0x302054UL : 0x102450UL)
  705. #define REG_FRAMES (ft8xx_model ? 0x302004UL : 0x102404UL)
  706. #define REG_FREQUENCY (ft8xx_model ? 0x30200cUL : 0x10240cUL)
  707. #define REG_GPIO (ft8xx_model ? 0x302094UL : 0x102490UL)
  708. #define REG_GPIO_DIR (ft8xx_model ? 0x302090UL : 0x10248cUL)
  709. #define REG_HCYCLE (ft8xx_model ? 0x30202cUL : 0x102428UL)
  710. #define REG_HOFFSET (ft8xx_model ? 0x302030UL : 0x10242cUL)
  711. #define REG_HSIZE (ft8xx_model ? 0x302034UL : 0x102430UL)
  712. #define REG_HSYNC0 (ft8xx_model ? 0x302038UL : 0x102434UL)
  713. #define REG_HSYNC1 (ft8xx_model ? 0x30203cUL : 0x102438UL)
  714. #define REG_ID (ft8xx_model ? 0x302000UL : 0x102400UL)
  715. #define REG_INT_EN (ft8xx_model ? 0x3020acUL : 0x10249cUL)
  716. #define REG_INT_FLAGS (ft8xx_model ? 0x3020a8UL : 0x102498UL)
  717. #define REG_INT_MASK (ft8xx_model ? 0x3020b0UL : 0x1024a0UL)
  718. #define REG_MACRO_0 (ft8xx_model ? 0x3020d8UL : 0x1024c8UL)
  719. #define REG_MACRO_1 (ft8xx_model ? 0x3020dcUL : 0x1024ccUL)
  720. #define REG_OUTBITS (ft8xx_model ? 0x30205cUL : 0x102458UL)
  721. #define REG_PCLK (ft8xx_model ? 0x302070UL : 0x10246cUL)
  722. #define REG_PCLK_POL (ft8xx_model ? 0x30206cUL : 0x102468UL)
  723. #define REG_PLAY (ft8xx_model ? 0x30208cUL : 0x102488UL)
  724. #define REG_PLAYBACK_FORMAT (ft8xx_model ? 0x3020c4UL : 0x1024b4UL)
  725. #define REG_PLAYBACK_FREQ (ft8xx_model ? 0x3020c0UL : 0x1024b0UL)
  726. #define REG_PLAYBACK_LENGTH (ft8xx_model ? 0x3020b8UL : 0x1024a8UL)
  727. #define REG_PLAYBACK_LOOP (ft8xx_model ? 0x3020c8UL : 0x1024b8UL)
  728. #define REG_PLAYBACK_PLAY (ft8xx_model ? 0x3020ccUL : 0x1024bcUL)
  729. #define REG_PLAYBACK_READPTR (ft8xx_model ? 0x3020bcUL : 0x1024acUL)
  730. #define REG_PLAYBACK_START (ft8xx_model ? 0x3020b4UL : 0x1024a4UL)
  731. #define REG_PWM_DUTY (ft8xx_model ? 0x3020d4UL : 0x1024c4UL)
  732. #define REG_PWM_HZ (ft8xx_model ? 0x3020d0UL : 0x1024c0UL)
  733. #define REG_ROTATE (ft8xx_model ? 0x302058UL : 0x102454UL)
  734. #define REG_SOUND (ft8xx_model ? 0x302088UL : 0x102484UL)
  735. #define REG_SWIZZLE (ft8xx_model ? 0x302064UL : 0x102460UL)
  736. #define REG_TAG (ft8xx_model ? 0x30207cUL : 0x102478UL)
  737. #define REG_TAG_X (ft8xx_model ? 0x302074UL : 0x102470UL)
  738. #define REG_TAG_Y (ft8xx_model ? 0x302078UL : 0x102474UL)
  739. #define REG_TOUCH_ADC_MODE (ft8xx_model ? 0x302108UL : 0x1024f4UL)
  740. #define REG_TOUCH_CHARGE (ft8xx_model ? 0x30210cUL : 0x1024f8UL)
  741. #define REG_TOUCH_DIRECT_XY (ft8xx_model ? 0x30218cUL : 0x102574UL)
  742. #define REG_TOUCH_DIRECT_Z1Z2 (ft8xx_model ? 0x302190UL : 0x102578UL)
  743. #define REG_TOUCH_MODE (ft8xx_model ? 0x302104UL : 0x1024f0UL)
  744. #define REG_TOUCH_OVERSAMPLE (ft8xx_model ? 0x302114UL : 0x102500UL)
  745. #define REG_TOUCH_RAW_XY (ft8xx_model ? 0x30211cUL : 0x102508UL)
  746. #define REG_TOUCH_RZ (ft8xx_model ? 0x302120UL : 0x10250cUL)
  747. #define REG_TOUCH_RZTHRESH (ft8xx_model ? 0x302118UL : 0x102504UL)
  748. #define REG_TOUCH_SCREEN_XY (ft8xx_model ? 0x302124UL : 0x102510UL)
  749. #define REG_TOUCH_SETTLE (ft8xx_model ? 0x302110UL : 0x1024fcUL)
  750. #define REG_TOUCH_TAG (ft8xx_model ? 0x30212cUL : 0x102518UL)
  751. #define REG_TOUCH_TAG_XY (ft8xx_model ? 0x302128UL : 0x102514UL)
  752. #define REG_TOUCH_TRANSFORM_A (ft8xx_model ? 0x302150UL : 0x10251cUL)
  753. #define REG_TOUCH_TRANSFORM_B (ft8xx_model ? 0x302154UL : 0x102520UL)
  754. #define REG_TOUCH_TRANSFORM_C (ft8xx_model ? 0x302158UL : 0x102524UL)
  755. #define REG_TOUCH_TRANSFORM_D (ft8xx_model ? 0x30215cUL : 0x102528UL)
  756. #define REG_TOUCH_TRANSFORM_E (ft8xx_model ? 0x302160UL : 0x10252cUL)
  757. #define REG_TOUCH_TRANSFORM_F (ft8xx_model ? 0x302164UL : 0x102530UL)
  758. #define REG_TRACKER (ft8xx_model ? 0x309000UL : 0x109000UL)
  759. #define REG_TRIM (ft8xx_model ? 0x302180UL : 0x10256cUL)
  760. #define REG_VCYCLE (ft8xx_model ? 0x302040UL : 0x10243cUL)
  761. #define REG_VOFFSET (ft8xx_model ? 0x302044UL : 0x102440UL)
  762. #define REG_VOL_PB (ft8xx_model ? 0x302080UL : 0x10247cUL)
  763. #define REG_VOL_SOUND (ft8xx_model ? 0x302084UL : 0x102480UL)
  764. #define REG_VSIZE (ft8xx_model ? 0x302048UL : 0x102444UL)
  765. #define REG_VSYNC0 (ft8xx_model ? 0x30204cUL : 0x102448UL)
  766. #define REG_VSYNC1 (ft8xx_model ? 0x302050UL : 0x10244cUL)
  767. #define VERTEX2II(x, y, handle, cell) \
  768. ((2UL << 30) | (((x) & 511UL) << 21) | (((y) & 511UL) << 12) | (((handle) & 31) << 7) | (((cell) & 127) << 0))
  769. #define ROM_PIXEL_FF 0xc0400UL
  770. class Poly {
  771. int x0, y0, x1, y1;
  772. int x[8], y[8];
  773. byte n;
  774. void restart() {
  775. n = 0;
  776. x0 = 16 * 480;
  777. x1 = 0;
  778. y0 = 16 * 272;
  779. y1 = 0;
  780. }
  781. void perim() {
  782. for (byte i = 0; i < n; i++)
  783. GD.Vertex2f(x[i], y[i]);
  784. GD.Vertex2f(x[0], y[0]);
  785. }
  786. public:
  787. void begin() {
  788. restart();
  789. GD.ColorMask(0,0,0,0);
  790. GD.StencilOp(KEEP, INVERT);
  791. GD.StencilFunc(ALWAYS, 255, 255);
  792. }
  793. void v(int _x, int _y) {
  794. x0 = min(x0, _x >> 4);
  795. x1 = max(x1, _x >> 4);
  796. y0 = min(y0, _y >> 4);
  797. y1 = max(y1, _y >> 4);
  798. x[n] = _x;
  799. y[n] = _y;
  800. n++;
  801. }
  802. void paint() {
  803. x0 = max(0, x0);
  804. y0 = max(0, y0);
  805. x1 = min(16 * 480, x1);
  806. y1 = min(16 * 272, y1);
  807. GD.ScissorXY(x0, y0);
  808. GD.ScissorSize(x1 - x0 + 1, y1 - y0 + 1);
  809. GD.Begin(EDGE_STRIP_B);
  810. perim();
  811. }
  812. void finish() {
  813. GD.ColorMask(1,1,1,1);
  814. GD.StencilFunc(EQUAL, 255, 255);
  815. GD.Begin(EDGE_STRIP_B);
  816. GD.Vertex2ii(0, 0);
  817. GD.Vertex2ii(511, 0);
  818. }
  819. void draw() {
  820. paint();
  821. finish();
  822. }
  823. void outline() {
  824. GD.Begin(LINE_STRIP);
  825. perim();
  826. }
  827. };
  828. #if SDCARD
  829. class Streamer {
  830. public:
  831. void begin(const char *rawsamples,
  832. uint16_t freq = 44100,
  833. byte format = ADPCM_SAMPLES,
  834. uint32_t _base = (0x40000UL - 8192), uint16_t size = 8192) {
  835. r.openfile(rawsamples);
  836. base = _base;
  837. mask = size - 1;
  838. wp = 0;
  839. for (byte i = 10; i; i--)
  840. feed();
  841. GD.sample(base, size, freq, format, 1);
  842. }
  843. int feed() {
  844. uint16_t rp = GD.rd32(REG_PLAYBACK_READPTR) - base;
  845. uint16_t freespace = mask & ((rp - 1) - wp);
  846. if (freespace >= 512) {
  847. // REPORT(base);
  848. // REPORT(rp);
  849. // REPORT(wp);
  850. // REPORT(freespace);
  851. // Serial.println();
  852. byte buf[512];
  853. // uint16_t n = min(512, r.size - r.offset);
  854. // n = (n + 3) & ~3; // force 32-bit alignment
  855. GD.__end();
  856. r.readsector(buf);
  857. GD.resume();
  858. GD.cmd_memwrite(base + wp, 512);
  859. GD.copyram(buf, 512);
  860. wp = (wp + 512) & mask;
  861. }
  862. return r.offset < r.size;
  863. }
  864. void progress(uint16_t &val, uint16_t &range) {
  865. uint32_t m = r.size;
  866. uint32_t p = min(r.offset, m);
  867. while (m > 0x10000) {
  868. m >>= 1;
  869. p >>= 1;
  870. }
  871. val = p;
  872. range = m;
  873. }
  874. private:
  875. Reader r;
  876. uint32_t base;
  877. uint16_t mask;
  878. uint16_t wp;
  879. };
  880. #else
  881. class Streamer {
  882. public:
  883. void begin(const char *rawsamples,
  884. uint16_t freq = 44100,
  885. byte format = ADPCM_SAMPLES,
  886. uint32_t _base = (0x40000UL - 4096), uint16_t size = 4096) {}
  887. int feed() {}
  888. void progress(uint16_t &val, uint16_t &range) {}
  889. };
  890. #endif
  891. static byte sinus(byte x)
  892. {
  893. return 128 + GD.rsin(128, -16384 + (x << 7));
  894. }
  895. // JCB{
  896. static void caption(int t, const char *text)
  897. {
  898. if ((0 <= t) && (t < 128)) {
  899. int sz = strlen(text) * 8;
  900. GD.RestoreContext();
  901. GD.Begin(LINES);
  902. GD.LineWidth(9 * 16);
  903. byte fade;
  904. if (t < 96)
  905. fade = 0xff;
  906. else
  907. fade = 0xff - ((t - 96) * 8);
  908. GD.ColorA(fade >> 1);
  909. GD.ColorRGB(0x000000);
  910. int y = 259;
  911. byte slide = sinus(min(255, t * 16));
  912. int x = ((slide * (long)sz) >> 8);
  913. GD.Vertex2ii(480, y);
  914. GD.Vertex2ii(470 - x, y);
  915. GD.ColorRGB(0xffffff);
  916. if (t < 16) {
  917. GD.ColorA(fade >> 2);
  918. for (int i = 8; i >= 0; i -= 2)
  919. GD.cmd_text(470 - x + sz + i, y, 26, OPT_CENTERY | OPT_RIGHTX, text);
  920. } else {
  921. GD.ColorA(fade);
  922. GD.cmd_text(470 - x + sz, y, 26, OPT_CENTERY | OPT_RIGHTX, text);
  923. }
  924. }
  925. }
  926. // }JCB
  927. #endif