API tools faq
paste
Advertisement
luizrosalba

Projetos_Arduino

luizrosalba
Sep 15th, 2019
183
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Arduino 16.63 KB | None | 0 0
raw download clone embed print report
  1. ///     Jogo da Velha 3D
  2. ///     Luiz Fernando Rosalba Sousa -  Nova Friburgo
  3. ///     IV SIimpósio Nacional da Formação do Professor de MAtemática
  4.  
  5. //// Teclado Membrana
  6. #include <Keypad.h> //INCLUSÃO DE BIBLIOTECA
  7. #include <Adafruit_NeoPixel.h>
  8. #ifdef __AVR__
  9. #include <Avr/Power.H>
  10. #endif
  11.  
  12. // porta de cada painel
  13. #define PINN1 13
  14. #define PINN2 12
  15. #define PINN3 2
  16. #define PINN4 7
  17.  
  18. //Parametros: Numero De Leds, Pino De Ligacao
  19. Adafruit_NeoPixel Strip1=Adafruit_NeoPixel(16,PINN1,NEO_GRB + NEO_KHZ800);
  20. Adafruit_NeoPixel Strip2=Adafruit_NeoPixel(16,PINN2,NEO_GRB + NEO_KHZ800);
  21. Adafruit_NeoPixel Strip3=Adafruit_NeoPixel(16,PINN3,NEO_GRB + NEO_KHZ800);
  22. Adafruit_NeoPixel Strip4=Adafruit_NeoPixel(16,PINN4,NEO_GRB + NEO_KHZ800);
  23.  
  24.  
  25.  
  26. const byte qtdLinhas = 4; //QUANTIDADE DE LINHAS DO TECLADO
  27. const byte qtdColunas = 4; //QUANTIDADE DE COLUNAS DO TECLADO
  28.  
  29. //CONSTRUÇÃO DA MATRIZ DE CARACTERES
  30. char matriz_teclas[qtdLinhas][qtdColunas] = {
  31.   {'1','2','3','A'},
  32.   {'4','5','6','B'},
  33.   {'7','8','9','C'},
  34.   {'*','0','#','D'}
  35. };
  36.  
  37. byte PinosqtdLinhas[qtdLinhas] = {3, 4, 5, 6}; //PINOS UTILIZADOS PELAS LINHAS
  38. byte PinosqtdColunas[qtdColunas] = {8, 9, 10,11}; //PINOS UTILIZADOS PELAS COLUNAS
  39.  
  40. ////////////////////////////////
  41. //CONSTRUÇÃO DA MATRIZ DE ON/OFF para validacao da jogada
  42. /////////////////////////////////
  43.    
  44.    
  45.     int Validacao[65];
  46.  
  47.    
  48. //INICIALIZAÇÃO DO TECLADO
  49. Keypad meuteclado = Keypad( makeKeymap(matriz_teclas), PinosqtdLinhas, PinosqtdColunas, qtdLinhas, qtdColunas);    
  50.  
  51. ////////////////////////////////
  52. /// Variaveis globais do programa
  53. /////////////
  54. int vez=0;           ///    de quem eh a vez
  55. int coordenada=0;
  56. char x='0',
  57.      y='0',
  58.      z='0';
  59. char tcant='0';
  60.  
  61. char tp ;            /// tecla pressionada
  62. int jogada =0 ;
  63.  
  64. void setup()
  65. {
  66.  
  67.   Serial.begin(9600); //INICIALIZA A SERIAL
  68.   Strip1.begin();
  69.   Strip1.show();
  70.  
  71.   Strip2.begin();
  72.   Strip2.show();
  73.  
  74.   Strip3.begin();
  75.   Strip3.show();
  76.  
  77.   Strip4.begin();
  78.   Strip4.show();
  79.  
  80.     //// Inicializacao dos Pinos
  81.      // for (int i = 2 ; i < 54 ; i++ )
  82.      //   pinMode(i, OUTPUT);    /// 23 vermelho
  83.     ////  
  84.  
  85.    /// Inicializacao Jogo
  86.    Reinicia();
  87.  
  88.    
  89.     /// TODO: acender um led para indicar de quem eh a jogada
  90.     ///
  91.     ////
  92.     Strip1.setBrightness(20);
  93.     Strip2.setBrightness(20);
  94.     Strip3.setBrightness(20);
  95.     Strip4.setBrightness(20);
  96.     ApagaTudo();
  97. }
  98.  
  99.  
  100. void loop()
  101. {
  102.  
  103.  
  104.     char tecla_pressionada = meuteclado.getKey(); //VERIFICA SE ALGUMA DAS TECLAS FOI PRESSIONADA
  105.  
  106.    
  107.     /// Imprime de quem eh a vez
  108.     //  if (Vez(jogada) == 0)
  109.     //    Serial.println("Jogada Vermelho");
  110.     //  else
  111.     //    Serial.println("Jogada Azul");
  112.    
  113.        if (tecla_pressionada)
  114.         {
  115.           tcant=tecla_pressionada;
  116.          
  117.           if (tecla_pressionada=='*' && tcant=='*') {coordenada=4; Reinicia(); }
  118.           if (coordenada==2) {z = tecla_pressionada; coordenada++; ImprimeJogada();} /// coordenada z
  119.           if (coordenada==1) {y = tecla_pressionada; coordenada++;} /// coordenada y
  120.           if (coordenada==0) {x = tecla_pressionada; coordenada++;} /// coordenada x
  121.          
  122.         }
  123.        
  124.         if (coordenada==3) /// terminou de dar as coordenadas da jogada Verificar validade da jogadas
  125.           {
  126.            
  127.               if (Verifica_Jogada_Valida(x,y,z)==true) /// se a jogada eh valida
  128.               {
  129.                
  130.                 int n=ACtoI(x,y,z);
  131.                 /// marca a matriz com a cor do jogador
  132.                 Validacao[n]=Vez(jogada);
  133.                 /// acende o led na cor do jogador
  134.                 AcendeLed(n,Vez(jogada));
  135.                 /// passa a jogada
  136.                 jogada++;
  137.                
  138.                
  139.               }else {
  140.               Serial.println("Jogada Inválida Repita sua Jogada ");
  141.               /// pisca led com cor falso (fazer)
  142.              
  143.               /// nao passa jogada
  144.                
  145.               }
  146.               coordenada=0; /// pede a proxima jogada    
  147.           }
  148.  
  149.           if (coordenada==4)
  150.           {
  151.             coordenada=0;  
  152.           }
  153.    
  154.     int venc=VerificaVencedor();
  155.    
  156.     if (venc!=2)
  157.     {
  158.       Serial.println("Vencedor");
  159.       Serial.println(venc);  
  160.       Reinicia();
  161.     }  // verificar se o cubo esta todo aceso sem vencedor
  162.    
  163.  
  164.    
  165.     //
  166.    
  167.  
  168.    
  169.    
  170.  
  171.  
  172.   // TestaLed();
  173.  
  174.    
  175.    delay(10);
  176. }
  177.  
  178. void ImprimeJogada()
  179. {
  180.   Serial.print("Jogada: ");  Serial.print(x); Serial.print(" ");  Serial.print(y);  Serial.print(" ");  Serial.print(z); Serial.println();
  181.  
  182.   }
  183.  
  184. void AcendeLed(int n, int vez)
  185. {
  186.  
  187.  int fita = ((n-1)/16)+1; /// diz qual andar
  188.  //Serial.println("fita ");
  189.  //Serial.println(fita);
  190.  
  191.  
  192.  
  193.  
  194.   if (fita==1)
  195.   {
  196.    int pos = n ;
  197.    if (vez==0)  Strip1.setPixelColor(Pos_painel_led(pos)-1, Strip1.Color(100, 0, 0));
  198.    else Strip1.setPixelColor(Pos_painel_led(pos)-1, Strip1.Color(0, 0, 100));
  199.    
  200.    Strip1.show();
  201.   }
  202.  
  203.   if (fita==2)
  204.   {
  205.    int pos = n-16 ;
  206.    if (vez==0)  Strip2.setPixelColor(Pos_painel_led(pos)-1, Strip2.Color(100, 0, 0));
  207.    else Strip2.setPixelColor(Pos_painel_led(pos)-1, Strip2.Color(0, 0, 100));
  208.    Strip2.show();
  209.   }
  210.    
  211.   if (fita==3)
  212.   {
  213.    int pos = n-32;
  214.    if (vez==0)  Strip3.setPixelColor(Pos_painel_led(pos)-1, Strip3.Color(100, 0, 0));
  215.    else Strip3.setPixelColor(Pos_painel_led(pos)-1, Strip3.Color(0, 0, 100));
  216.    Strip3.show();
  217.   }
  218.  
  219.   if (fita==4)
  220.   {
  221.    int pos = n-48;
  222.    if (vez==0)  Strip4.setPixelColor(Pos_painel_led(pos)-1, Strip4.Color(100, 0, 0));
  223.    else Strip4.setPixelColor(Pos_painel_led(pos)-1, Strip4.Color(0, 0, 100));
  224.    Strip4.show();
  225.   }
  226.  
  227.   if (fita<1 || fita >4)
  228.   {
  229.     Serial.print(" Erro de fita");  
  230.   }
  231.   //Serial.print("n ");
  232.   //Serial.println(n);
  233. }
  234.  
  235.  
  236. void ApagaLed(int n)
  237. {
  238.  
  239.  int fita = ((n-1)/16)+1; /// diz qual andar
  240.  //Serial.println("fita ");
  241.  //Serial.println(fita);
  242.  
  243.   if (fita==1)
  244.   {
  245.    int pos = n ;
  246.    Strip1.setPixelColor(Pos_painel_led(pos)-1, Strip1.Color(0, 0, 0));
  247.    
  248.    Strip1.show();
  249.   }
  250.  
  251.   if (fita==2)
  252.   {
  253.    int pos = n-16 ;
  254.    Strip2.setPixelColor(Pos_painel_led(pos)-1, Strip2.Color(0, 0, 0));
  255.    Strip2.show();
  256.   }
  257.    
  258.   if (fita==3)
  259.   {
  260.    int pos = n-32;
  261.    Strip3.setPixelColor(Pos_painel_led(pos)-1, Strip3.Color(0, 0, 0));
  262.    
  263.    Strip3.show();
  264.   }
  265.  
  266.   if (fita==4)
  267.   {
  268.    int pos = n-48;
  269.    Strip4.setPixelColor(Pos_painel_led(pos)-1, Strip4.Color(0, 0, 0));
  270.  
  271.    Strip4.show();
  272.   }
  273.  
  274.   if (fita<1 || fita >4)
  275.   {
  276.     Serial.print(" Erro de fita");  
  277.   }
  278.   //Serial.print("n ");
  279.   //Serial.println(n);
  280. }
  281.  
  282. void ApagaTudo()
  283. {
  284.    for (int I = 0; I < Strip1.numPixels(); I++)
  285.    {
  286.       Strip1.setPixelColor(I, Strip1.Color(0, 0, 0));
  287.       Strip1.show();
  288.    }
  289.  
  290.    for (int I = 0; I < Strip2.numPixels(); I++)
  291.    {
  292.       Strip2.setPixelColor(I, Strip2.Color(0, 0, 0));
  293.       Strip2.show();
  294.    }
  295.  
  296.    for (int I = 0; I < Strip3.numPixels(); I++)
  297.    {
  298.       Strip3.setPixelColor(I, Strip3.Color(0, 0, 0));
  299.       Strip3.show();
  300.    }
  301.  
  302.    for (int I = 0; I < Strip4.numPixels(); I++)
  303.    {
  304.       Strip4.setPixelColor(I, Strip4.Color(0, 0, 0));
  305.       Strip4.show();
  306.    }
  307.    
  308. }
  309.  
  310. int Pos_painel_led (int ent) // retorna a indexação do painel de led
  311. {
  312.  
  313. if (ent ==1)return 4;
  314. if (ent ==2)return 3;
  315. if (ent ==3)return 2;
  316. if (ent ==4)return 1;
  317.  
  318. if (ent ==9)return 12;
  319. if (ent ==10)return 11;
  320. if (ent ==11)return 10;
  321. if (ent ==12)return 9;
  322.  
  323. return ent;
  324.  
  325. }
  326.  void TestaLed()
  327.  {
  328.    
  329.   for (int I = 1; I <= Strip1.numPixels(); I++)
  330.    {
  331.            
  332.       Strip1.setPixelColor(Pos_painel_led(I)-1, Strip1.Color(200, 0, 0)); /// vermelho
  333.       Strip1.show();
  334.       delay(100);
  335.    }
  336.  
  337.  
  338.    for (int I = 1; I <= Strip2.numPixels(); I++)
  339.    {
  340.       Strip2.setPixelColor(Pos_painel_led(I)-1, Strip2.Color(0,200,0)); /// verde
  341.       Strip2.show();
  342.        delay(100);
  343.    }
  344.  
  345.    for (int I = 1; I <= Strip3.numPixels(); I++)
  346.    {
  347.       Strip3.setPixelColor(Pos_painel_led(I)-1, Strip3.Color(0,0,200)); /// azul
  348.       Strip3.show();
  349.        delay(100);
  350.    }
  351.  
  352.     for (int I = 1; I <= Strip4.numPixels(); I++)
  353.    {
  354.       Strip4.setPixelColor(Pos_painel_led(I)-1, Strip4.Color(200, 200, 150)); /// branco
  355.       Strip4.show();
  356.        delay(100);
  357.    }
  358.  
  359.  }
  360.  
  361. int ACtoI (char ix , char iy , char iz)
  362. {
  363.  
  364. int xi= (ix)-'0';
  365. int yi= (iy)-'0';
  366. int zi= (iz)-'0';
  367.  
  368. int n =((xi-1)*4 + yi +(zi-1)*4*4);
  369. return (n);
  370. }
  371.  
  372.  
  373. int AItoI (int xi , int yi , int zi)
  374. {
  375. int n =((xi-1)*4 + yi +(zi-1)*4*4);
  376. return (n);
  377. }
  378.  
  379.  
  380.  
  381. bool Verifica_Jogada_Valida( char ix , char iy , char iz)
  382. {
  383.     int xi= (ix)-'0';
  384.     int yi= (iy)-'0';
  385.     int zi= (iz)-'0';
  386.     int n = AItoI(xi,yi,zi);
  387.    /// Serial.print(n);
  388.    
  389.     if (n>64 || n<1) {Serial.println("Jogada Fora do Intervalo do Cubo");return false; }
  390.    
  391.     if (xi>4 || yi>4 || zi>4)  {Serial.println("Coordenadas Devem ser menores que 4");return false; }
  392.     if (xi<1 || yi<1 || zi<1)  {Serial.println("Coordenadas não podem ser menores que 1");return false; }
  393.  
  394.     /// verificar letras
  395.    
  396.     if (Validacao[n]==3) return true; /// vazio
  397.     if (Validacao[n]==0) {Serial.println("Vermelho já jogou nessa posicao");return false; } /// vermelho
  398.     if (Validacao[n]==1) {Serial.println("Azul já jogou nessa posicao");return false; }   /// azul
  399.  
  400.     return false;
  401.    
  402.  
  403. }
  404.  
  405. //// Retorna 0 se vez do vermelhro
  406. //// Retorna 1 se vez do azul
  407. int Vez(int ent)
  408. {
  409.   if ((ent%2)==0)
  410.     return 0; /// vermelho
  411.   else
  412.     return 1;  /// azul
  413.    
  414.  }
  415.  
  416.   //////////////////////////////
  417.   /// loop da selecao de teclas
  418.   /////////////////////////////
  419.   void Reinicia()
  420. {
  421.    vez=0; /// vermelhos reiniciam
  422.    jogada=0; /// vermelhos jogam
  423.    coordenada=0;
  424.    tcant='0';
  425.  /// Inicializacao vetor  validacao
  426.     for (int i=0;i<=64;i++)
  427.     {
  428.        Validacao[i]= 3 ; /// 3 = posicao nao jogada
  429.                          /// 0 = jogada vermelho
  430.                          /// 1 = jogada azul
  431.     }                      
  432.  
  433.  
  434.     ApagaTudo();
  435.  
  436. }
  437.  
  438.  
  439. void ItoA(int pos,int &saida_fita, int &saida_M)
  440. {
  441.   if (pos>=1 && pos <=16)
  442.   {
  443.     saida_fita =1 ;
  444.     saida_M= pos;  
  445.   }
  446.  
  447.   if (pos>=17 && pos <=32)
  448.   {
  449.     saida_fita =2 ;
  450.     saida_M= (pos-16);  
  451.   }
  452.   if (pos>=33 && pos <=48)
  453.   {
  454.     saida_fita =3 ;
  455.     saida_M= (pos-32);  
  456.   }
  457.   if (pos>=49 && pos <=64)
  458.   {
  459.     saida_fita =4 ;
  460.     saida_M= (pos-48);  
  461.   }
  462.  
  463. }
  464.  
  465. void PiscaLinha (int pos1 , int pos2 ,int pos3 ,int pos4 , int venc)
  466. {
  467.  
  468.     int tempopisca=500;
  469.     /*
  470.      Serial.println(pos1);
  471.       Serial.println(pos2);
  472.       Serial.println(pos3);
  473.       Serial.println(pos4);
  474.       Serial.println(" ");
  475. */
  476.      
  477. for (int i=1;i<=5;i++)// numero de piscadas
  478.   {
  479.  
  480.    
  481.       ApagaLed(pos1);
  482.       ApagaLed(pos2);
  483.       ApagaLed(pos3);
  484.       ApagaLed(pos4);
  485.       delay(tempopisca);
  486.       AcendeLed(pos1,venc);
  487.       AcendeLed(pos2,venc);
  488.       AcendeLed(pos3,venc);
  489.       AcendeLed(pos4,venc);
  490.       delay(tempopisca);
  491.      
  492.      
  493.   }
  494.  
  495.  
  496.  
  497.  
  498. }
  499. /// 0 = vencedor vermelhor
  500. /// 1 = vencedor azul
  501. /// 2 = nenhum vencedor
  502.  
  503. int  VerificaVencedor()
  504. {
  505.       int a, bb,c,d;
  506.       /// linhas  
  507.       for (int i=1; i<=61 ; i=i+4) /// cada linha
  508.       {
  509.           a=i; bb=i+1;c=i+2;d=i+3;
  510.          
  511.           if (Validacao[a]==0 && Validacao[bb]==0 && Validacao[c]==0 && Validacao[d]==0 ) { PiscaLinha(a,bb,c,d,0); return 0;}
  512.           if (Validacao[a]==1 && Validacao[bb]==1 && Validacao[c]==1 && Validacao[d]==1 ) { PiscaLinha(a,bb,c,d,1); return 1;}
  513.       }
  514.       /// coluna
  515.        for (int i=1; i<=52 ; i=i+1) /// cada linha
  516.       {
  517.           if (i==5) i=17; /// confere 1,2 ,3 ,4 pula do 5 para 17
  518.           if (i==21) i=33; ///confere 17,18,19,20 pula do 21 para 31
  519.           if (i==37) i=49; ///confere 33,34,35,36 pula do 37 para 0 49
  520.                             /// confere 49,50,51,52 e finaliza no 53
  521.  
  522.           a=i; bb=i+4;c=i+8;d=i+12;      
  523.                
  524.           if (Validacao[a]==0 && Validacao[bb]==0 && Validacao[c]==0 && Validacao[d]==0 ) { PiscaLinha(a,bb,c,d,0); return 0;}
  525.           if (Validacao[a]==1 && Validacao[bb]==1 && Validacao[c]==1 && Validacao[d]==1 ) { PiscaLinha(a,bb,c,d,1); return 1;}
  526.       }
  527.       /// verticais  
  528.       for (int i=1; i<16 ; i=i+1) /// cada coluna vertical
  529.       {
  530.            a=i; bb=i+16;c=i+32;d=i+48;    
  531.            if (Validacao[a]==0 && Validacao[bb]==0 && Validacao[c]==0 && Validacao[d]==0 ) { PiscaLinha(a,bb,c,d,0); return 0;}
  532.            if (Validacao[a]==1 && Validacao[bb]==1 && Validacao[c]==1 && Validacao[d]==1 ) { PiscaLinha(a,bb,c,d,1); return 1;}
  533.       }
  534.       //////Cruz no eixo decrescente
  535.       for (int i=1; i<=49 ; i=i+16) /// cada andar tem duas cruz
  536.       {
  537.            a=i; bb=i+5;c=i+10;d=i+15;    
  538.            if (Validacao[a]==0 && Validacao[bb]==0 && Validacao[c]==0 && Validacao[d]==0 ) { PiscaLinha(a,bb,c,d,0); return 0;}
  539.            if (Validacao[a]==1 && Validacao[bb]==1 && Validacao[c]==1 && Validacao[d]==1 ) { PiscaLinha(a,bb,c,d,1); return 1;}
  540.       }
  541.       for (int i=4; i<=52 ; i=i+16) /// cada andar tem duas cruz
  542.       {
  543.            a=i; bb=i+3;c=i+6;d=i+9;    
  544.            if (Validacao[a]==0 && Validacao[bb]==0 && Validacao[c]==0 && Validacao[d]==0 ) { PiscaLinha(a,bb,c,d,0); return 0;}
  545.            if (Validacao[a]==1 && Validacao[bb]==1 && Validacao[c]==1 && Validacao[d]==1 ) { PiscaLinha(a,bb,c,d,1); return 1;}
  546.       }
  547.      
  548.       // diagonais só as bordas podem. Os cantos podem diagonal , e duas laterais  
  549.      
  550.       for (int i=1; i<=4 ; i++) ////// diagonal paralela ao eixo y cima
  551.       {
  552.             a=i; bb=i+20;c=i+40;d=i+60;
  553.            if (Validacao[a]==0 && Validacao[bb]==0 && Validacao[c]==0 && Validacao[d]==0 ) { PiscaLinha(a,bb,c,d,0); return 0;}
  554.            if (Validacao[a]==1 && Validacao[bb]==1 && Validacao[c]==1 && Validacao[d]==1 ) { PiscaLinha(a,bb,c,d,1); return 1;}
  555.        }
  556.      
  557.       /// diagonal paralela ao eixo y baixo
  558.        for (int i=13; i<=16 ; i++) ////// diagonal paralela ao eixo y Baixo
  559.       {
  560.             a=i; bb=i+12;c=i+24;d=i+36;
  561.            if (Validacao[a]==0 && Validacao[bb]==0 && Validacao[c]==0 && Validacao[d]==0 ) { PiscaLinha(a,bb,c,d,0); return 0;}
  562.            if (Validacao[a]==1 && Validacao[bb]==1 && Validacao[c]==1 && Validacao[d]==1 ) { PiscaLinha(a,bb,c,d,1); return 1;}
  563.       }
  564.      
  565.       /// diagonal paralela ao eixo x esquerda
  566.        for (int i=1; i<=13 ; i=i+4) ////// diagonal paralela ao eixo x esquerda
  567.       {
  568.             a=i; bb=i+17;c=i+34;d=i+51;
  569.            if (Validacao[a]==0 && Validacao[bb]==0 && Validacao[c]==0 && Validacao[d]==0 ) { PiscaLinha(a,bb,c,d,0); return 0;}
  570.            if (Validacao[a]==1 && Validacao[bb]==1 && Validacao[c]==1 && Validacao[d]==1 ) { PiscaLinha(a,bb,c,d,1); return 1;}
  571.       }
  572.      
  573.       /// diagonal paralela ao eixo x direita
  574.      
  575.       for (int i=4; i<=16 ; i=i+4) ////// diagonal paralela ao eixo x direita
  576.       {
  577.            a=i; bb=i+15;c=i+30;d=i+45;
  578.            if (Validacao[a]==0 && Validacao[bb]==0 && Validacao[c]==0 && Validacao[d]==0 ) { PiscaLinha(a,bb,c,d,0); return 0;}
  579.            if (Validacao[a]==1 && Validacao[bb]==1 && Validacao[c]==1 && Validacao[d]==1 ) { PiscaLinha(a,bb,c,d,1); return 1;}
  580.       }
  581.      
  582.      
  583.       /// diagonal principal
  584.        a=1; bb=22;c=43;d=64;
  585.        if (Validacao[1]==0 && Validacao[22]==0 && Validacao[43]==0 && Validacao[64]==0 ) { PiscaLinha(a,bb,c,d,0); return 0;}
  586.        if (Validacao[1]==1 && Validacao[22]==1 && Validacao[43]==1 && Validacao[64]==1 ) { PiscaLinha(a,bb,c,d,1); return 1;}
  587.        a=4; bb=23;c=42;d=61;
  588.        if (Validacao[4]==0 && Validacao[23]==0 && Validacao[42]==0 && Validacao[61]==0 ) { PiscaLinha(a,bb,c,d,0); return 0;}
  589.        if (Validacao[4]==1 && Validacao[23]==1 && Validacao[42]==1 && Validacao[61]==1 ) { PiscaLinha(a,bb,c,d,1); return 1;}
  590.         a=16; bb=27;c=38;d=49;
  591.        if (Validacao[16]==0 && Validacao[27]==0 && Validacao[38]==0 && Validacao[49]==0 ) { PiscaLinha(a,bb,c,d,0); return 0;}
  592.        if (Validacao[16]==1 && Validacao[27]==1 && Validacao[38]==1 && Validacao[49]==1 ) { PiscaLinha(a,bb,c,d,1); return 1;}
  593.       a=13; bb=26;c=39;d=52;
  594.       if (Validacao[13]==0 && Validacao[26]==0 && Validacao[39]==0 && Validacao[52]==0 ) { PiscaLinha(a,bb,c,d,0); return 0;}
  595.       if (Validacao[13]==1 && Validacao[26]==1 && Validacao[39]==1 && Validacao[52]==1 ) { PiscaLinha(a,bb,c,d,1); return 1;}
  596.  
  597.  
  598.      
  599.  
  600.  
  601.      
  602. return 2; /// nenhum vencedor
  603.    
  604. }
  605.  
  606.  
  607.  
  608.  
  609. void desliga (int pos , uint32_t cor)
  610. {
  611.   Strip1.setPixelColor(pos, Strip1.Color(0, 0, 0));
  612.   Strip1.show();
  613. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!