sample.ino 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228
  1. #include <SPI.h>
  2. #include <GD.h>
  3. // ----------------------------------------------------------------------
  4. // controller: buttons on Arduino pins 3,4,5,6 with 7 grounded
  5. // ----------------------------------------------------------------------
  6. static void controller_init()
  7. {
  8. // Configure input pins with internal pullups
  9. byte i;
  10. for (i = 3; i < 7; i++) {
  11. pinMode(i, INPUT);
  12. digitalWrite(i, HIGH);
  13. }
  14. // drive pin 7 low
  15. pinMode(7, OUTPUT);
  16. digitalWrite(7, 0);
  17. }
  18. #define CONTROL_LEFT 1
  19. #define CONTROL_RIGHT 2
  20. #define CONTROL_UP 4
  21. #define CONTROL_DOWN 8
  22. static byte controller_sense()
  23. {
  24. byte r = 0;
  25. if (!digitalRead(5))
  26. r |= CONTROL_DOWN;
  27. if (!digitalRead(4))
  28. r |= CONTROL_UP;
  29. if (!digitalRead(6))
  30. r |= CONTROL_LEFT;
  31. if (!digitalRead(3))
  32. r |= CONTROL_RIGHT;
  33. return r;
  34. }
  35. #define FLOCAL 2
  36. #define SEL_local() digitalWrite(FLOCAL, LOW)
  37. #define UNSEL_local() digitalWrite(FLOCAL, HIGH)
  38. struct dirent {
  39. char name[12];
  40. uint16_t length;
  41. uint32_t addr;
  42. };
  43. static uint32_t flash_readn(byte *dst, uint32_t src, size_t n)
  44. {
  45. SEL_local();
  46. SPI.transfer(0x03);
  47. SPI.transfer((byte)(src >> 16));
  48. SPI.transfer((byte)(src >> 8));
  49. SPI.transfer((byte)(src >> 0));
  50. while (n--) {
  51. *dst++ = SPI.transfer(0);
  52. src++;
  53. if ((511 & (uint16_t)src) == 264)
  54. src = src - 264 + 512;
  55. }
  56. UNSEL_local();
  57. return src;
  58. }
  59. uint16_t samp_len;
  60. uint32_t samp_ptr;
  61. static dirent de;
  62. static byte find_name(uint32_t &ptr, uint16_t &len, uint32_t dirptr, char *name)
  63. {
  64. while (true) {
  65. dirptr = flash_readn((byte*)&de, dirptr, sizeof(de));
  66. if (de.name[0] == 0)
  67. return 0; // end of dir, no match found
  68. if (strcmp(de.name, name) == 0) {
  69. len = de.length;
  70. ptr = de.addr;
  71. return 1;
  72. }
  73. }
  74. }
  75. static byte ninstruments;
  76. static dirent instruments[32];
  77. struct active {
  78. byte instrument;
  79. uint32_t addr;
  80. uint16_t pos, length;
  81. uint16_t x, y;
  82. };
  83. #define NACTIVE 3
  84. static active playing[NACTIVE];
  85. struct active *findidle()
  86. {
  87. byte i;
  88. for (i = 0; i < NACTIVE; i++)
  89. if (playing[i].addr == 0)
  90. return &playing[i];
  91. return NULL;
  92. }
  93. static void kickoff(byte i)
  94. {
  95. active *p = findidle();
  96. if (p) {
  97. p->addr = instruments[i].addr;
  98. p->pos = 0;
  99. p->length = instruments[i].length;
  100. p->x = 0;
  101. p->y = 16 + 16 * i;
  102. }
  103. }
  104. static void fromflash(uint16_t dst, uint32_t src, uint16_t len)
  105. {
  106. while (len--) {
  107. byte v;
  108. src = flash_readn(&v, src, 1);
  109. GD.wr(dst++, v);
  110. }
  111. }
  112. static byte sprstr(int x, int y, byte spr, const char *txt)
  113. {
  114. char c;
  115. while ((c = *txt++) != 0) {
  116. GD.sprite(spr++, x, y, (c - ' ') >> 2, 8 + ((c & 3) << 1), 0);
  117. x += 11;
  118. }
  119. return spr;
  120. }
  121. // add all samples from dir
  122. void add_samples(uint32_t dir)
  123. {
  124. dirent *pi = &instruments[ninstruments];
  125. while (dir = flash_readn((byte*)pi, dir, sizeof(*pi)), pi->name[0]) {
  126. pi++, ninstruments++;
  127. }
  128. }
  129. void setup()
  130. {
  131. controller_init();
  132. GD.begin();
  133. GD.ascii();
  134. pinMode(FLOCAL, OUTPUT);
  135. UNSEL_local();
  136. GD.wr(IOMODE, 'F');
  137. uint32_t assetroot = 512L * 640;
  138. uint32_t dk;
  139. uint16_t dkl;
  140. find_name(dk, dkl, assetroot, "voice");
  141. add_samples(dk);
  142. find_name(dk, dkl, assetroot, "drumkit");
  143. add_samples(dk);
  144. byte i;
  145. for (i = 0; i < ninstruments; i++) {
  146. byte x = (50 - strlen(instruments[i].name)) >> 1;
  147. GD.putstr(x, 2 + i, instruments[i].name);
  148. }
  149. uint32_t sd;
  150. uint16_t sdl;
  151. if (1) {
  152. find_name(dk, dkl, assetroot, "pickups");
  153. find_name(sd, sdl, dk, "pal");
  154. fromflash(RAM_SPRPAL, sd, sdl);
  155. find_name(sd, sdl, dk, "img");
  156. fromflash(RAM_SPRIMG, sd, sdl);
  157. }
  158. }
  159. #include "soundbuffer.h"
  160. #define SOUNDBUFFER 0x3f00
  161. int cursor;
  162. void loop()
  163. {
  164. GD.microcode(soundbuffer_code, sizeof(soundbuffer_code));
  165. byte writepointer = 0;
  166. for (;;) {
  167. active *p;
  168. byte i;
  169. byte readpointer = GD.rd(COMM+0);
  170. byte fullness = writepointer - readpointer;
  171. while (fullness < 254) {
  172. char total = 0;
  173. for (p = playing, i = 0; i < NACTIVE; p++, i++) {
  174. if (p->addr) {
  175. char v;
  176. p->addr = flash_readn((byte*)&v, p->addr, 1);
  177. total += (v >> 1);
  178. if (++p->pos >= p->length)
  179. p->addr = 0;
  180. }
  181. }
  182. GD.wr(SOUNDBUFFER + writepointer++, total);
  183. fullness++;
  184. }
  185. GD.waitvblank();
  186. GD.sprite(0, 142, 11 + 8 * cursor, 47, 0, 0);
  187. GD.sprite(1, 238, 11 + 8 * cursor, 47, 0, 2);
  188. static byte prev;
  189. byte press;
  190. press = controller_sense();
  191. if (prev == 0) {
  192. if (press & CONTROL_DOWN)
  193. cursor = min(ninstruments - 1, cursor + 1);
  194. if (press & CONTROL_UP)
  195. cursor = max(0, cursor - 1);
  196. if (press & (CONTROL_RIGHT | CONTROL_LEFT))
  197. kickoff(cursor);
  198. }
  199. prev = press;
  200. }
  201. }