Simple single-color 8x8x8 LED Cube with AVRs
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.

cube.c 5.7KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206
  1. /*
  2. * cube.c
  3. *
  4. * Copyright 2012 Thomas Buck <xythobuz@me.com>
  5. *
  6. * This file is part of LED-Cube.
  7. *
  8. * LED-Cube is free software: you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation, either version 3 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * LED-Cube is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with LED-Cube. If not, see <http://www.gnu.org/licenses/>.
  20. */
  21. // Uses Timer 1!
  22. #include <avr/io.h>
  23. #include <avr/interrupt.h>
  24. #include <stdlib.h>
  25. #include <util/atomic.h>
  26. #include <avr/pgmspace.h>
  27. #include "cube.h"
  28. #ifndef F_CPU
  29. #define F_CPU 16000000L
  30. #endif
  31. /*
  32. * 24 fps, 8 layers => 192 Interrupts per second
  33. * We are at 16MHz, so we count to:
  34. * 16000000 / 192 = 83333,33...
  35. * We can only count to 2^16, therefore we have a second counter
  36. * COUNT * (COUNT2 + 1) = Realcount
  37. * 41666 * 2 = 83332
  38. * This is flickering really hard.
  39. *
  40. * COUNT2 set to 0 on the other hand, thus producing 48fps,
  41. * works flicker-free. Now we just return imgFlag / 2 as isFinished(),
  42. * so we still fake 24fps for the main program...
  43. */
  44. #define COUNT 41666
  45. #define COUNT2 0
  46. volatile uint8_t imgBuffer[8][8];
  47. volatile uint8_t changedFlag = 0;
  48. volatile uint8_t imgFlag = 0;
  49. volatile uint8_t layer = 0;
  50. volatile uint8_t toggleFlag = 0;
  51. volatile uint32_t timesTriggered = 0;
  52. volatile uint8_t warningDisplayed = 0;
  53. // A fix for our mirrored 64pin cable.
  54. // Look around line 150 to change this
  55. uint8_t lookUp[256] PROGMEM = { 0, 64, 128, 192, 16, 80, 144, 208, 32, 96, 160,
  56. 224, 48, 112, 176, 240, 4, 68, 132, 196, 20,
  57. 84, 148, 212, 36, 100, 164, 228, 52, 116, 180,
  58. 244, 8, 72, 136, 200, 24, 88, 152, 216, 40,
  59. 104, 168, 232, 56, 120, 184, 248, 12, 76, 140,
  60. 204, 28, 92, 156, 220, 44, 108, 172, 236, 60,
  61. 124, 188, 252, 1, 65, 129, 193, 17, 81, 145,
  62. 209, 33, 97, 161, 225, 49, 113, 177, 241, 5,
  63. 69, 133, 197, 21, 85, 149, 213, 37, 101, 165,
  64. 229, 53, 117, 181, 245, 9, 73, 137, 201, 25,
  65. 89, 153, 217, 41, 105, 169, 233, 57, 121, 185,
  66. 249, 13, 77, 141, 205, 29, 93, 157, 221, 45,
  67. 109, 173, 237, 61, 125, 189, 253, 2, 66, 130,
  68. 194, 18, 82, 146, 210, 34, 98, 162, 226, 50,
  69. 114, 178, 242, 6, 70, 134, 198, 22, 86, 150,
  70. 214, 38, 102, 166, 230, 54, 118, 182, 246, 10,
  71. 74, 138, 202, 26, 90, 154, 218, 42, 106, 170,
  72. 234, 58, 122, 186, 250, 14, 78, 142, 206, 30,
  73. 94, 158, 222, 46, 110, 174, 238, 62, 126, 190,
  74. 254, 3, 67, 131, 195, 19, 83, 147, 211, 35,
  75. 99, 163, 227, 51, 115, 179, 243, 7, 71, 135,
  76. 199, 23, 87, 151, 215, 39, 103, 167, 231, 55,
  77. 119, 183, 247, 11, 75, 139, 203, 27, 91, 155,
  78. 219, 43, 107, 171, 235, 59, 123, 187, 251, 15,
  79. 79, 143, 207, 31, 95, 159, 223, 47, 111, 175,
  80. 239, 63, 127, 191, 255 };
  81. ISR(TIMER1_COMPA_vect) {
  82. uint8_t latchCtr;
  83. if (toggleFlag >= COUNT2) {
  84. if (changedFlag != 0) {
  85. // The picture changed. Restart!
  86. layer = 0;
  87. changedFlag = 0;
  88. }
  89. PORTD = 0;
  90. PORTB &= ~(24); // Disable all Fets
  91. for (latchCtr = 0; latchCtr < 8; latchCtr++) {
  92. // Disable all latches
  93. PORTC &= ~(0xFC); // 2 - 7
  94. PORTB &= ~(6); // 0 & 1
  95. PORTA = imgBuffer[layer][latchCtr]; // Put latch data
  96. // Enable desired latch
  97. if (latchCtr > 1) {
  98. PORTC |= (1 << latchCtr);
  99. } else {
  100. PORTB |= (1 << (latchCtr + 1));
  101. }
  102. }
  103. // Set FET
  104. PORTD = (1 << layer); // PD2 to 7
  105. PORTB = (PORTB & ~(24)) | (((1 << layer) << 3) & 24); // PB3 & 4
  106. // Select next layer
  107. if (layer < 7) {
  108. layer++;
  109. } else {
  110. layer = 0;
  111. imgFlag++; // Finished
  112. }
  113. toggleFlag = 0;
  114. timesTriggered++;
  115. } else {
  116. toggleFlag++;
  117. }
  118. }
  119. uint32_t getTriggerCount(void) {
  120. return timesTriggered;
  121. }
  122. void setImage(uint8_t *img) {
  123. uint8_t i, j;
  124. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  125. changedFlag = 1;
  126. imgFlag = 0;
  127. toggleFlag = 0;
  128. for (i = 0; i < 8; i++) {
  129. for (j = 0; j < 8; j++) {
  130. // First line uses the lookUp Table to account for our wrong connection
  131. imgBuffer[j][7 - i] = ~(pgm_read_byte(&(lookUp[img[j + (i * 8)]])));
  132. // This line is simply displaying the data, for correct connections
  133. // imgBuffer[j][i] = ~(img[j + (i * 8)]);
  134. // Uncomment the desired line, comment the other...
  135. }
  136. }
  137. }
  138. }
  139. void fillBuffer(uint8_t val) {
  140. uint8_t i, j;
  141. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  142. changedFlag = 1;
  143. imgFlag = 0;
  144. toggleFlag = 0;
  145. for (i = 0; i < 8; i++) {
  146. for (j = 0; j < 8; j++) {
  147. imgBuffer[i][j] = ~(val);
  148. }
  149. }
  150. }
  151. }
  152. uint8_t isFinished(void) {
  153. return (imgFlag / 2);
  154. }
  155. void initCube(void) {
  156. uint8_t x, y;
  157. TCCR1B |= (1 << CS10) | (1 << WGM12); // Prescaler: 1, CTC Mode
  158. OCR1A = COUNT;
  159. TIMSK = (1 << OCIE1A); // Enable Output Compare Interrupt
  160. fillBuffer(0); // Clear memory
  161. sei(); // Enable interrupts
  162. // Show test animation
  163. for (x = 0; x < 8; x++) {
  164. for (y = 0; y < 8; y++) {
  165. ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  166. imgBuffer[x][y] &= ~(0xFF); // Set a pixel
  167. changedFlag = 1;
  168. imgFlag = 0;
  169. toggleFlag = COUNT2; // Ensure next interrupts starts displaying
  170. }
  171. while(imgFlag < 1); // Wait for frame to display
  172. }
  173. }
  174. cli(); // Disable interrupts
  175. timesTriggered = 0;
  176. imgFlag = 0;
  177. toggleFlag = 0;
  178. }