Comando paraCada()

.github/workflows/compile.yml

@@ -135,6 +135,11 @@ jobs:
         run: |
           arduino-cli compile --fqbn ${{ matrix.fqbn }} ${{ matrix.flag-programmer }} ./examples/Intermediario/ASCII
 
+      - name: Compile Sketch paraCada.ino
+        if: matrix.serial-enabled == true
+        run: |
+          arduino-cli compile --fqbn ${{ matrix.fqbn }} ${{ matrix.flag-programmer }} ./examples/Intermediario/paraCada
+
       - name: Compile Sketch quarentaedois.ino
         if: matrix.serial-enabled == true
         run: |

TABELA_DE_INSTRUCOES.md

@@ -19,6 +19,7 @@ Estruturas de controle são estruturas do tipo condicional, que irão analisar u
 | se               | Analisa se a condição dentro do parâmetro é verdadeira e executa uma ação.                                                                                                                                        | se(a == b) { <br> // ação caso "a = b" <br> }                                                                                                                                                                                |
 | senao            | Executa uma ação se o parâmetro da condição ``se`` for falso.                                                                                                                                                     | se(a == b) { <br> // ação caso "a = b" <br> } <br> senao { <br> // ação caso "a ≠ b" <br> }                                                                                                                                  |
 | para             | Executa um bloco de instruções enquanto uma condição for satisfeita. É utilizado um contador para incrementar, ou decrementar, e terminar o loop.                                                                 | para(x = 0; x < 2; x = x+1) { <br> /\* executa este bloco enquanto "x" for menor que 2 \*/ <br> }                                                                                                                            |
+| paraCada         | Executa uma varredura em um vetor/matriz enquanto não se chegar ao fim do mesmo ou ser forçada uma quebra de laço.                                                                                                | paraCada(celula,vetor){ <br> /\* executa esse bloco ate o fim do vetor ser atingido \*/ <br> }                                                                                                                                            |
 | contarAte        | Aplicação da função ``para`` onde se escolhe o número de iterações.                                                                                                                                               | contarAte(5) { <br> /\* executa este bloco de instruções 5 vezes \*/ <br> }                                                                                                                                                  |
 | enquanto         | Esta função executa continuamente enquanto o teste do parâmetro for verdadeiro.                                                                                                                                   | enquanto(x == 2) { <br> /\* ações a serem executadas enquanto o parâmetro for verdadeiro, ou seja, enquanto "x = 2" \*/ <br> }                                                                                               |
 | comparar....caso | Compara o parâmetro da função com os casos definidos. No exemplo, "x" é comparado com os valores 1 e 2. É utilizado a instrução ``sair`` para que não se realize os próximos testes se algum já for o verdadeiro. | comparar(x) { <br><br> caso 1: <br> /\* ação caso "x = 1" \*/ <br> sair; <br><br> caso 2: <br> /\* ação caso "x = 2" \*/ <br> sair; <br><br> padrao: <br> /\* executa se não for nenhum dos casos \*/ <br> sair; <br> }      |

examples/Intermediario/paraCada/paraCada.ino

@@ -0,0 +1,61 @@
+/*
+    paraCada(A,B)
+    Um melhoramento da função para(for) que auxilia o programador a percorrer um vetor ou matriz de dados até os seu fim.
+
+    Uso: 
+
+    paraCada(A,B)
+    {
+        escreverSerial(A);
+    }
+
+    Variáveis:
+     A (Variável a ser preenchida com os valores do vetor/matriz que está sendo lido).
+     B (Vetor/matriz a ser percorrido durante o laço).
+
+     O laço irá executar até o fim do vetor/matriz ser atingido ou uma condição de quebra seja
+     forçada.
+
+    Este exemplo de código está em domínio público.
+
+    criado em 28 de abril de 2018
+    modificado em 19 de abril de 2021
+    Desenvolvido por Alesson Renato.
+    Modificado por Steffano Pereira
+    Contribuição a biblioteca Brasilino.
+
+    Este exemplo é baseado em código aberto referente a linguagem C++/Arduino.
+*/  
+
+// Inclue a biblioteca Brasilino
+#include <Brasilino.h>
+
+// A funcao configurar executa uma vez quando a placa é ligada ou quando o botão de reset é pressionado
+funcao configurar() {
+    // Inicializa a comunicação serial com a placa
+    iniciarSerial();
+}
+
+// A funcao repetir executa para sempre
+funcao repetir() {
+    // Cria a variável celula que armazenará o conteudo das celulas do vetor, cria posição que demonstrará a posição da celula atual e por fim cria um vetor com valores inteiros
+    inteiro celula, posicao = 0, vetor[10] = {10,9,8,7,6,5,4,3,2,1};
+    // Chama a função paraCada que guardará em celula um valor de posição do vetor que cada iteração
+    paraCada(celula,vetor){
+        // Escreve Posicao na serial
+        escreverSerial("Posicao:");
+        // Escreve a posição lida atual
+        escreverSerial(posicao);
+        // Escreve um espaço entre os valores e a palavra Valor:
+        escreverSerial(" Valor:");
+        // Escreve o valor contido na celula atual e pula uma linha
+        escreverSerialn(celula);  
+        esperar(0.5); // espera meio segundo
+        posicao++; // atualiza posição
+    }
+}
+/* 
+    OBS: O exemplo foi criado usando o tipo de dado inteiro, contudo a função é compatível com 
+    qualquer tipo de dado primitivo ou composto compatível com a linguagem C++. Porém não é
+    compatível com vetores/arrays multidimensionais.
+*/

keywords.txt

@@ -28,6 +28,7 @@ escrever	KEYWORD2
 ler	KEYWORD2
 esperar	KEYWORD2
 esperarMili	KEYWORD2
+paraCada	KEYWORD2
 ligar	KEYWORD2
 desligar	KEYWORD2
 escreverAnalogico	KEYWORD2

src/Brasilino.h

@@ -60,6 +60,17 @@
 #define contarAte(y) for (int x = 0; x < y; x++)
 #define contarDe(y) for (int x = y; x > 0; x--)
 
+//-----------paraCada(foreach)-------------
+#define paraCada(item, array) \
+for (typeof(*(array)) *p = (array), (item) = *p; \
+     p < &((array)[sizeof (array)/sizeof (typeof (*(array)))]); \
+     p++, (item) = *p)
+/*Baseado na solução de: https://stackoverflow.com/a/47133982/11855220
+ *
+ *Internaliza a função `for` e trabalha com o ponteiro `p` que 
+ *percorre todo o array de acordo com o tamanho do array
+ */
+
 //------------------Funções---------------------
 #define imprimir print
 #define imprimirLinha println