GD2.h 31 KB

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