A linguagem rEduc foi criada para facilitar a programação de robôs em linguagens mais complexas (no caso do sBotics, C#). Ela reúne as estruturas básicas e tipos de dados que um usuário pode precisar para programar seus robôs. Ao “compilar” rEduc, o simulador converte o código em C# para que o robô consiga executar o que foi programado sem o usuário precisar ter conhecimentos de programação avançada em C#.

Neste tutorial apresentaremos as principais estruturas desta linguagem.

Aviso! rEduc também tem uma versão em inglês, porém neste tutorial estamos tratando da versão pt-BR do rEduc, a mais utilizada por usuários do sBotics.

Todo programa na linguagem rEduc deve conter as palavras reservadas inicio e fim que indicam que sequência de comandos deve ser executada ao iniciar o programa. Os programas na linguagem rEduc devem conter obrigatoriamente a seguinte estrutura:

inicio
    comandos
fim

A linguagem rEduc opera sobre três tipos de dados: texto, numero e booleano. As variáveis de cada um destes tipos devem ser definidas antes do início do programa. Elas podem ter seus valores alterados dentro das tarefas ou no bloco de comandos após o início e antes do fim.

Texto

O tipo de dado texto manipula variáveis do tipo string, que são sequências de símbolos e caracteres/letras delimitados por aspas. Abaixo temos um exemplo da criação de uma variável do tipo texto com nome variavel e conteúdo “valor”.

texto variavel = "valor"

Para alterar o conteúdo da variável texto para “novo valor” o seguinte comando deverá ser efetuado:

variavel = "novo valor"

Número

O tipo de dado numero manipula variáveis do tipo double, números que podem assumir valores inteiros ou decimais. Abaixo temos um exemplo da criação de uma variável do tipo numero com nome variavel e conteúdo 3.

numero variavel = 3

Para alterar o conteúdo da variável numero para 5 o seguinte comando deverá ser efetuado:

variavel = 5.3

Números também podem ser representados através de equações:

variavel = 5-3

Aviso! rEduc não possui suporte para números negativos, é necessário utilizar uma equação do tipo “0-”

# Equivale a -5
variavel = 0-5

Booleano (Verdadeiro / Falso)

O tipo de dado booleano manipula variáveis lógicas do tipo verdadeiro ou falso. Abaixo temos um exemplo da criação de uma variável do tipo booleano com nome variavel e conteúdo verdadeiro.

booleano variavel = verdadeiro

Para alterar o conteúdo da variável booleano para falso o seguinte comando deverá ser efetuado:

variavel = falso

É possível também adicionar comparações ou outros tipos de comparação booleana

variavel = Ultra("Nome do Meu Sensor Ultrassônico") <= 5

Aviso! Recomendamos que variáveis sejam inicializadas por um valor estático, com um número qualquer (como -1), texto qualquer (como “”) ou um valor booleano qualquer. Uma variável não deve ser iniciada por uma função do sBotics ou do usuário.

A linguagem rEduc possui os seguintes operadores lógicos e relacionais para condições booleanas (verdadeiro / falso):

e - e lógico

ou - ou lógico

! - não lógico

== - igual

!= - diferente

> - maior que

< - menor que

>= - maior ou igual que

<= - menor ou igual que

(5 > 3)
(Ultra("Nome do Meu Sensor Ultrasônico") <= 10)
(Toque("Nome do Meu Sensor de Toque") == verdadeiro)

Estes operadores podem ser utilizados em controladores de fluxo, que serão explicadas abaixo.

Tipos podem ser convertidos utilizando as funções VirarTexto(), VirarNumero() e VirarBooleano(). Estas funções farão as conversões dos seguintes tipos:

• VirarTexto(numero): Transforma o número informado em texto (Ex.: 5 virar "5");
• VirarNumero(texto):Transforma o texto informado em número (Ex.: "5" virar 5);
• VirarBooleano(numero):Transforma o número informado em booleano (Ex.: 1 virar verdadeiro).

Na conversão em booleano, caso o número informado seja 1 ou acima a conversão sairá como verdadeiro, e 0 ou abaixo para ser falso.

A linguagem rEduc possui as seguintes estruturas controladoras de fluxo: se, enquanto, farei, repita, teste, para e sair. A seguir apresentaremos como deve ser escrita cada uma dessas estruturas.

Se

A estrutura se da linguagem rEduc representa o comando de seleção se-então e se-senão-então presente em todas as linguagens de programação. Esta estrutura ao ser utilizada permite selecionar quais os comandos que serão executados caso uma determinada condição seja satisfeita.

se (condicao booleana) entao{
    comandos
}

com senão:

se (condicao booleana) entao{
    comandos
} senao {
    outros comandos
}

Enquanto

A estrutura enquanto da linguagem rEduc representa um comando de repetição condicional. A ideia básica é fazer com que a execução de uma série de comandos seja repetida enquanto uma determinada condição for satisfeita. Quando a condição não for mais satisfeita a repetição é finalizada.

enquanto (condicao booleana) farei {
    comandos
}

Farei

A estrutura farei da linguagem rEduc representa um comando de repetição condicional assim como o enquanto apresentado anteriormente. A única diferença entre esta estrutura e a anterior é que nesta primeiro sequência de comandos é realizada e, em seguida, a condição é avaliada, caso a condição seja satisfeita os comandos são novamente executados.

farei {
    comandos
} enquanto (condicao booleana)

Repita

A estrutura repita da linguagem rEduc representa um comando de repetição contada. A utilização desta estrutura faz com que um conjunto de comandos seja executado determinado número de vezes. Abaixo apresentamos como deve ser utilizada esta estrutura para que um conjunto de comando seja executado 5 vezes.

repita 5 vezes {
    comandos
}

O rEduc não dá suporte a comandos “repita” dentro de outros comandos “repita”. Cuidado com o seu código e evite problemas.

Teste

A estrutura teste da linguagem rEduc representa um comando de seleção. A utilização desta estrutura faz com que o valor de uma variável do tipo texto fornecida seja avaliado e dependendo de seu valor uma determinada sequência de comandos é realizada. No código abaixo a variável testada foi chamada de variavel e caso o seu valor seja igual a valor1 a sequência de comandos denominada no código como comandos1 será executada, caso seu valor seja igual a valor2 o conjunto comandos2 será executado. Caso seu valor não seja nenhum dos apresentados a sequência de comandos denominada de comandos3 será executada.

teste ( variavelDeTexto ) {
    caso valor1: comandos1
    caso valor2: comandos2
    outros: comandos3
}

Para

A estrutura para da linguagem rEduc representa um comando de repetição contada. A utilização desta estrutura faz com que um conjunto de comandos seja executado determinado número de vezes. A quantidade de vezes que a sequência de comandos é realizada vai depender do valor da variável de controle que vai assumir valores desde um limite superior até um limite inferior, percorrendo-os de acordo com um determinado passo informado na estrutura. No código abaixo a variável de controle foi chamada de contador, o limite inferior e superior de 0 e 10 respectivamente e o passo de 1 (ou seja, a cada repetição ele vai somar “1” (passo) à variável “contador”).

# a variável de controle do para deve ser definida antes do "inicio"
numero contador = 0

inicio
    para contador de 0 ate 10 passo 1 farei {
        comandos
    }
fim

Para utilizar essa estrutura é necessário definir a variável utilizada previamente antes do “inicio”, no cabeçalho/topo do programa.

Um programa escrito em rEduc pode conter tarefas, conjunto de comandos nomeados que também são chamados de funções, procedimentos ou sub-rotinas. Para que esta estrutura seja utilizada elas devem ser declaradas antes do início do programa. A declaração de uma tarefa com nome “funcao” por exemplo, é feita como segue:

tarefa nomedafuncao {
    comandos
}

Ao declarar uma tarefa a sequência de comandos contida nela não será executada. Para que a execução de seus comandos seja realizada é necessário que o seu nome seja chamado. Para que a sequência de comandos inserida na tarefa função seja executada, por exemplo, é necessário que seja digitado o seguinte comando:

nomedafuncao()

Tarefas com parâmetros permitem que comandos mais avançados sejam chamados, e tarefas repetitivas sejam simplificadas. Abaixo temos alguns exemplos de tarefas com parâmetros.

tarefa Direita com numero forca {
    Motor("motor-esquerdo", forca)
    Motor("motor-esquerdo-traseiro", forca)
    Motor("motor-direito", 0-forca)
    Motor("motor-direito-traseiro", 0-forca)
}

tarefa LigarLed com numero vermelho, numero verde, numero azul  {
    LigarLuz("meu-led-0", vermelho, verde, azul)
    LigarLuz("meu-led-1", vermelho, verde, azul)
    LigarLuz("meu-led-2", vermelho, verde, azul)
}

Funções podem ser chamadas da mesma forma que tarefas, porém passando os parâmetros que ela pede.

Direita(200)

LigarLed(255,255,255)

Funções no sBotics são como tarefas, porém que retornam algum valor em um dos tipos já citados: numérico, em texto ou booleano.

Desta forma, toda função precisa de um tipo de retorno e uma instrução de retorno. Exemplos:

funcao booleano TaPerto {
    booleano verificacao = (Ultra("Nome do Meu Sensor Ultrassonico") <= 5)
    retornar verificacao
}

funcao numero UmMaisUm {
    retornar 1+1
}

E como tarefas, também podem receber parâmetros:

funcao numero UmMaisAlgo com numero algo {
    retornar 1+algo
}

Da mesma forma que tarefas, funções podem ser chamadas no seu código

se(TaPerto())

numero exemplo = UmMaisUm()

numero exemplodois = UmMaisAlgo(5)

Conceito mais avançado, porém tarefas e funções podem possuir valores-padrão para os parâmetros se informados após o símbolo =. Isto é, os parâmetros mais a direita (e precisam estar mais a direita na hora de escrever a função) podem possuir um valor padrão que caso não seja(m) informado(s) será(ão) utilizado(s).

tarefa Frente com numero velocidade = 200 {
	Motor("meu-motor-esquerdo", velocidade)
	Motor("meu-motor-direito", velocidade)
}

Isto poderá ser chamado como:

# Normalmente
Frente(500)

# Sem o parâmetro, que utilizará o valor padrão de 200 como definido
Frente()

Comandos gerais para a linguagem rEduc, desde operações matemáticas a controle do robô etc podem ser encontrados aqui: Comandos.

Para aprender outros conceitos gerais de Programação e sobre Componentes, basta acessar as outras páginas associadas da wiki.

Segue abaixo um código de exemplo de um simples seguidor de linha para o robô “Trekker” padrão do sBotics usando rEduc.

# Funções de Controle
tarefa Frente com numero velocidade = 200{
        TravarMotor("l", falso) # Destrava o motor da esquerda
        TravarMotor("r", falso) # Destrava o motor da direita

        Motor("l", velocidade)
        Motor("r", velocidade)
}

tarefa Direita com numero velocidade = 200{
        Motor("r", 0)
        TravarMotor("r", verdadeiro) # Trava o motor da direita

        TravarMotor("l", falso) # Destrava o motor da esquerda
        Motor("l", velocidade*2)
}

tarefa Esquerda com numero velocidade = 200{
        Motor("l", 0)
        TravarMotor("l", verdadeiro) # Trava o motor da esquerda

        TravarMotor("r", falso) # Destrava o motor da direita
        Motor("r", velocidade*2)
}

tarefa Tras com numero velocidade = 200{
        TravarMotor("l", falso) # Destrava o motor da esquerda
        TravarMotor("r", falso) # Destrava o motor da direita

        Motor("l", 0-velocidade)
        Motor("r", 0-velocidade)
}

numero contador = 0
tarefa LedFinal {
    para contador de 1 ate 5 passo 1 farei {
        LigarLuz("led", 255, 0, 0)
        Esperar(50)
        LigarLuz("led", 0, 255, 0)
        Esperar(50)
        LigarLuz("led", 0, 0, 255)
        Esperar(50)
    }
}

inicio
    AbrirConsole()
    
    enquanto (verdadeiro) farei {
        EscreverLinha("Escrevendo no Console")
        se((Cor("rc") == "Preto") e (Cor("lc") != "Preto")) entao {
            LigarLuz("led", 0, 0, 255)
            Direita(300)
        } senao se((Cor("rc") != "Preto") e (Cor("lc") == "Preto")) entao {
            LigarLuz("led", 255, 0, 0)
            Esquerda(300)
        } senao se((Cor("rc") == "Preto") e (Cor("lc") == "Preto")) entao {
            LigarLuz("led", 0, 255, 0)
            Frente()
        } senao se((Cor("rc") == "Vermelho") ou (Cor("lc") == "Vermelho")) entao {
            Frente(0)
            LedFinal()
        } senao { 
            LigarLuz("led", 255, 0, 255)
            Frente()
        }

    }

fim

Caso seja um usuário avançado que deseja realizar tarefas mais difíceis e ter um controle total sobre seu robô, cogite alterar para C#.