Data hosted with ♥ by Pastebin.com - Download Raw - See Original
  1. //*----------------------
  2. // Laboratorio #6
  3. // Progrmama Arduino
  4. // Andres Satizabal
  5. // Version 1.0
  6.  
  7. //*----------------------
  8.  
  9. // se inicializan los pines para en envio de los datos
  10. // al integrado
  11. int latchPin = 8;
  12. int clockPin = 12;
  13. int dataPin = 11;
  14.  
  15. // se inicializan los arreglos para cada patrón
  16. int dato;
  17. int P_A[17] = {0, 240, 255, 15, 255, 15, 255, 240, 0};
  18. int P_B[16] = {0, 2, 4, 8, 16, 32, 64, 128, 64, 32, 16, 8, 4, 2, 1, 0};
  19. int P_C[9] = {0, 129, 66, 36, 24, 36, 66, 129, 0 };
  20. int P_D[10] = {0, 1, 5, 21, 85, 213, 245, 253, 255, 0};
  21. int P_E[7] = {0, 255, 189, 165, 161, 129, 0};
  22. int P_F[13] = {0, 1, 5, 21, 85, 213, 245, 253, 255, 0};
  23. int P_G[9] = {0, 3, 15, 63, 255, 243, 240, 192, 0};
  24. int P_H[9] = {0, 1, 129, 131, 195, 199, 231, 239, 255, 231, 195, 129, 0 };
  25.  
  26. // variable para la lectura del dato serial desde processing
  27. char Letra;
  28.  
  29. // config del programa
  30. void setup() {
  31.  
  32. // se configuran los pines como salidas y el modulo de com serial
  33. pinMode(latchPin, OUTPUT);
  34. pinMode(dataPin, OUTPUT);
  35. pinMode(clockPin, OUTPUT);
  36. Serial.begin(9600);
  37.  
  38. }
  39.  
  40. // Bucle de ejecución del programa
  41. void loop() {
  42.  
  43. // Si hay datos disponibles en el puerto serial
  44. if (Serial.available() > 0)
  45. {
  46. // Leer la letra actual en el buffer
  47. Letra = Serial.read();
  48.  
  49. // aqui se condiciona si la letra enviada está entre las
  50. // opciones y ejecuta el patron determinado
  51.  
  52. if (Letra == 'A'){
  53. Patron_A();
  54. }
  55. if (Letra == 'B'){
  56. Patron_B();
  57. }
  58. if (Letra == 'C'){
  59. Patron_C();
  60. }
  61. if (Letra == 'D'){
  62. Patron_D();
  63. }
  64. if (Letra == 'E'){
  65. Patron_E();
  66. }
  67. if (Letra == 'F'){
  68. Patron_F();
  69. }
  70. if (Letra == 'G'){
  71. Patron_G();
  72. }
  73. if (Letra == 'H'){
  74. Patron_H();
  75. }
  76.  
  77. // el bucle se ejecuta mientras hayan datos disponibles
  78. // por leer en el buffer.
  79.  
  80. }
  81. }
  82.  
  83. // a continuacion y hasta el final de codigo estan las funciones
  84. // para mostrar los patrones en cada caso descrito arriba.
  85.  
  86. void Patron_A(){
  87.  
  88. for (int j = 0; j < 17; j++) {
  89. // carga la secuencia del arreglo determinado.
  90. dato = P_A[j];
  91. // funcion de envio
  92. envio();
  93. delay(100);
  94. }
  95. }
  96.  
  97. void Patron_B(){
  98.  
  99. for (int j = 0; j < 16; j++) {
  100. // carga la secuencia del arreglo determinado
  101. dato = P_B[j];
  102. envio();
  103. delay(100);
  104. }
  105. }
  106.  
  107.  
  108.  
  109. void Patron_C(){
  110.  
  111. for (int j = 0; j < 9; j++) {
  112. // carga la secuencia del arreglo determinado
  113. dato = P_C[j];
  114. envio();
  115. delay(200);
  116. }
  117. }
  118.  
  119. void Patron_D(){
  120.  
  121. for (int j = 0; j < 10; j++) {
  122. // carga la secuencia del arreglo determinado
  123. dato = P_D[j];
  124. envio();
  125. delay(200);
  126. }
  127. }
  128.  
  129. void Patron_E(){
  130.  
  131. for (int j = 0; j < 7; j++) {
  132. // carga la secuencia del arreglo determinado
  133. dato = P_E[j];
  134. envio();
  135. delay(200);
  136. }
  137. }
  138.  
  139. void Patron_F(){
  140.  
  141. for (int j = 0; j < 13; j++) {
  142. // carga la secuencia del arreglo determinado
  143. dato = P_F[j];
  144. envio();
  145. delay(100);
  146.  
  147. }
  148. }
  149.  
  150. void Patron_G(){
  151.  
  152. for (int j = 0; j < 9; j++) {
  153. // carga la secuencia del arreglo determinado
  154. dato = P_G[j];
  155. envio();
  156. delay(300);
  157.  
  158. }
  159. }
  160.  
  161. void Patron_H(){
  162. for (int j = 0; j < 9; j++) {
  163. dato = P_H[j];
  164. envio();
  165. delay(300);
  166. }
  167. }
  168.  
  169. void envio(){
  170. // se pone el pin latch en cero para guardar el valor mientras se transmite.
  171. digitalWrite(latchPin, 0);
  172. //
  173. shiftOut(dataPin, clockPin, MSBFIRST, dato);
  174. // se regresa el pin latch a estado alto para esperar el nuevo valor
  175. digitalWrite(latchPin, 1);
  176. }