PROJETO DE UMA LINGUAGEM PARA PROGRAMAÇÃO

DE ROBÔS MANIPULADORES
Project of a programming language for robots manipulators

Moisés Ribeiro dos SANTOS JUNIOR

Faculdade de Jaguariúna

André MENDELECK (Orientador)

Faculdade de Jaguariúna

Resumo: Neste artigo apresentamos uma proposta de linguagem para programação

de movimentos de um robô manipulador com três graus de liberdade. A linguagem
tem características textuais em português e foi baseada na estrutura física de um
robô manipulador construído por alunos do curso de Engenharia de Controle e
Automação da FAJ.
Palavras-chave: Compiladores; Linguagem de Programação; Comandos.

Abstract: This article presents a proposal for a programming language for the
motion for a robot manipulator with three degrees of freedom. The language has
textual characteristics in Portuguese and was based on the physical structure of a
manipulator robot built by students of Control Engineering and Automation of the
FAJ.
Key-words: Compilers; programming language ; Commands.

1
 1. INTRODUÇÃO

A programação dos movimentos de um robô exige do desenvolvedor um

conjunto de competências e habilidades intrínsecas de várias áreas do
conhecimento. A complexidade dos movimentos solicita a utilização de ferramentas
computacionais que auxiliem na implementação das tarefas. A forma tradicional para
a programação de robôs manipuladores consiste na utilização de linguagens
textuais, tais como AL, AML entre outras.

A complexidade de movimentos e ações, principalmente em função do número

de graus de liberdade do mecanismo e da tarefa a ser implementada, faz-se
necessário a utilização de ferramentas computacionais amigáveis que auxiliem os
desenvolvedores de aplicações.

Nesse cenário, observamos que existe a necessidade de uma ferramenta de

auxílio em relação à programação dos movimentos do robô, como por exemplo, uma
linguagem de programação simplificada baseada em comandos textuais ou uma
IHM/IHC Gráfica.

Tomando por base um robô manipulador construído por alunos do curso de

Engenharia de Controle e Automação da FAJ foi possível verificar a necessidade da
criação de uma linguagem de programação que facilitasse o processo de controle de
movimentos do robô, de tal forma a facilitar o desenvolvimento de aplicações. Assim,
propomos uma linguagem de programação textual com comandos em língua
portuguesa formal, definidos em um ambiente de alto nível, permitindo controle dos
movimentos a serem executados pelos robôs.

2
 2. TIPOS DE LINGUAGEM DE PROGRAMAÇÃO DE ROBÔS

Existem diversas linguagens de programação desenvolvidas para o controle de

hardwares mecânicos. Devido ao grande avanço da robótica, cresce também a
necessidade de melhores ferramentas para o desenvolvimento de aplicações para
robôs manipuladores.

Devido à complexidade de movimentos e ações passíveis de implementação

nos robôs, faz-se necessário o desenvolvimento de ferramentas computacionais
amigáveis que auxiliem os desenvolvedores de aplicações.

Nesse cenário grandes empresas vêm procurando aprimorar o controle dos

robôs através de comandos que são definidos em linguagens específicas que
proporcionam o acionamento das funções que um hardware mecânico pode
executar, sem que haja um embasamento mais aprofundado em estudos de
estruturas de controle por parte de seu programador.

Abaixo pode ser observado as diversas linguagens de programação para robôs

existentes no mercado.

Figura 1 – Extraída da Revista Mecatrônica Atual de 11/02/2009

3
 3. ESTRUTURA DA LINGUAGEM PARA PROGRAMAÇÃO DE ROBÔS
MANIPULADORES E SUAS CARACTERISTICAS

A linguagem proposta está centrada em diretivas verbal no infinitivo, onde os

comandos iniciam por um verbo, associando a uma ação do robô. Na sequência é
esperado que seja digitado pelo programador um segundo comando, definindo para
qual servo-motor destina-se a ação imposta pelo verbo. E enfim é esperado o grau
intensidade com que esse comando agirá sobre os movimentos do robô, definidos
em números naturais positivos.

Por exemplo, LEVANTAR ANTEBRACO 10. Nesta estrutura textual temos os

caracteres alfanuméricos de um código da linguagem e o resultado esperado é que
haja um movimento de deslocamento vertical para cima do antebraço do robô, ou
seja, da posição em que ele se encontra para a posição definida no comando.

A linguagem tem por características comandos em português, escritos de

forma seqüencial baseados na estrutura física do robô manipulador que, com seus 3
graus de movimento interpreta a função de um braço humano. Com a linguagem
pretende-se de forma otimizada fornecer ao desenvolvedor, mais uma ferramenta
para auxilio no controle de um robô, através de comandos que possa fazer com que
suas rotinas sejam executadas.

Essa linguagem é compilável, ou seja, necessitará de um compilador que

compile seus códigos e os traduza de tal forma, que os comandos originais em
português sejam recodificados em comando específico para acionamento e controle
dos atuadores (servo-motores) instalados no mecanismo físico. Esse processo de
tradução consiste em traduzir o programa-fonte e para um programa-alvo especifico
para o robô.

A seguir é apresentada a lista de comandos que foram elaborados baseando

no robô manipulador construídos por alunos do Curso de Engenharia de Controle e
Automação da FAJ.
4
 VERBO: É o primeiro comando a ser digitado pelo programador sendo ele,
responsável pela ação dos movimentos do robô manipulador. (ABAIXAR, ABRIR,
FECHAR, LEVANTAR, GIRAR).

 SUBSTANTIVO: É o segundo comando a ser digitado pelo programador

responsável pelos motores do robô manipulador. (ANTEBRACO, BASE, GARRA
PUNHO)

 NUMERAL: E o terceiro comando a ser digitado pelo programador sendo

responsável pelo grau de intensidade dos movimentos do robô. (10, 20, 30, 40,
50,...)

Cada comando da linguagem está associado a controlar os servos-motores

que tenham relação com o que está sendo solicitado pelo programador. Por
exemplo: O programador digita um comando que pede para que o robô abaixe a sua
base em um determinado grau de intensidade. A solicitação não pode ser atendida
porque o comando que está associado à base do robô é o comando girar, ou seja, o
robô não foi desenvolvido para abaixar sua base e sim para gira - lá. Caso ocorra do
programador solicitar esse comando lhe será informado que essa operação não
compete ao servo-motor especificado.

Os macros comandos da linguagem foram definidos baseados em cada

movimento que o robô manipulador pode executar.

 ABAIXAR: Comando associado ao servo-motor ANTEBRACO e PUNHO.

Esse comando permite que os motores associados façam um deslocamento vertical
para baixo.

 ABRIR: Comando associado ao servo-motor GARRA. Esse comando permite

que o motor associado faça um movimento de abertura da garra.

5
  FECHAR: Comando associado ao servo-motor GARRA. Esse comando
permite que o motor associado faça um movimento de fechamento da garra.

 GIRAR: Comando associado ao servo-motor BASE. Esse comando permite

que o motor associado faça um movimento de giro da base.

 LEVANTAR: Comando associado ao servo-motor ANTEBRACO e PUNHO.

Esse comando permite que os motores associados façam um deslocamento vertical
para baixo.

Os comandos devem ser escritos de forma alternada, ou seja, um comando de

cada vez. Sendo assim o programador terá que verificar o comando que esteja
precisando para o momento e com qual motor irá trabalhar. Após essa análise o
programador poderá digitar o comando para que o robô execute a tarefa.

Nessa estrutura definimos as regras da seguinte forma:

1. Ação dos movimentos: Esse será sempre o primeiro comando a ser
digitado, ou seja, nele o programador definirá qual ação deseja

6
 Braço

Articulação

Punho

Articulação

Garra

Base

Articulação

Figura 2 – Esquema de um robô manipulador

7
 4. COMO A LINGUAGEM DE PROGRAMAÇÃO DE ROBÔS
MANIPULADORES PODERÁ SER USADA

A linguagem está sendo proposta baseada no robô manipulador que consta

na figura 2 deste artigo. O robô é composto por uma base e quatro motores.

O ambiente de desenvolvimento de aplicações e simulação estará integrado a

uma interface gráfica como apresentado na figura 3, para a execução dos comandos
digitados pelo programador. Abaixo segue a descrição detalhada das funções de
cada motor.

Comandos associados os atuadores-motores do robô manipulador:

 BASE = Base do robô (Comando associado ao servo-motor 1 )

 ANTEBRACO = Antebraço do robô (Comando associado ao servo-motor 2 )
 PUNHO = Punho do robô (Comando associado ao servo-motor 3 )
 GARRA = Garra do robô (Comando associado ao servo-motor 4 )

Comandos associados aos Movimentos dos links (estruturas do robô):

 M1 = GIRAR

 M2 = LEVANTAR; ABAIXAR

 M3 = LEVANTAR; ABAIXAR

 M4 = ABRIR; FECHAR

8
 Estes comandos podem ser associados produzindo uma sequência de
movimentos. A seguir apresentamos alguns exemplos de como esses comandos
poderão ser atribuídos ao robô manipulador através de digitações de códigos
propostos pela linguagem:

 GIRAR BASE 30

Obs.: Faz com que a base do robô gire em 30 graus.

 ABAIXAR ANTEBRACO 20

Obs.: Faz com que o braço do robô abaixe em 20 graus.

 LEVANTAR ANTEBRACO 10

Obs.: Faz com que o braço do robô levante em 10 graus.

 ABAIXAR PUNHO 40

Obs.: Faz com que o punho do robô abaixe em 40 graus.

 LEVANTAR PUNHO 30

Obs.: Faz com que o punho do robô levante em 30 graus.

 ABRIR GARRA 50

Obs.: Faz com que a garra do robô abra em 50 graus

 FECHAR GARRA 40

Obs.: Faz com que a garra do robô feche em 40 graus

9
 A figura abaixo refere-ser ao robô manipulador em seu estado inicial. Após
todas as operações em que o robô foi incumbido ele volta ao seu estado de origem e
está pronto para receber novas instruções de seu programador.

Figura 3 - Robô em seu estado inicial

10
 A figura abaixo simula que o robô tenha recebido um comando para girar sua
base. Notamos que houve um deslocamento horizontal à esquerda (olhando o robô
de frente). Obs. Essa simulação foi feita manualmente e o comando associado
refere-se a base do robô.

Figura 4 – Robô após receber comando

11
 5. IMPLEMENTAÇÃO DA LINGUAGEM PARA PROGRAMAÇÃO DE ROBÔS
MANIPULADORES PROPOSTA

Utilizando a linguagem de programação C++ foi desenvolvido um protótipo

de um compilador. Em um estudo sobre compiladores estabelecemos em 3 etapas a
criação de comandos para uma linguagem de alto nível ou seja, uma linguagem de
aproximação maior entre o hardware mecânico e o programador.

Na primeira etapa foi estudado sobre a análise léxica, ou seja, onde são
verificadas as sentenças de caracteres digitados pelo programador. Aqui definimos
através de algoritmos a verificação e validação dos caracteres de entradas
denominados em tokens de entrada. Foi feito a separação desses tokens e depois a
validação dos mesmos. Nota-se que o protótipo aceita que seja digitado quaisquer
termos porém, valida-os apenas os termos corretos de acordo com a sintaxe da
linguagem.

Após essa etapa passamos para a análise sintática onde definimos as

regras e o dicionário da linguagem. As regras e o dicionário foram definidos
baseados nos movimentos do robô juntamente com o nome dado a cada servo-
motor e o grau de intensidade do movimento a ser executado. A sintaxe da
linguagem está definida em palavras do vocabulário português em que se espera em
primeiro lugar uma ação a ser atribuída a um servo-motor.

Por fim fizemos a associação dos comandos da linguagem aos seus

respectivos servos-motores, ou seja, nesse estudo análise semântica observamos
como cada motor poderia estar sendo manipulado pela sintaxe da linguagem e a
qual comando seria atribuído essa associação. Por exemplo: É aceito pelo
compilador um comando em que o programador venha solicitar em que a base do
robô abaixe ou levante. Sabendo que a base do robô tem a finalidade de girar 360°
associamos o comando girar a base do robô. Abaixo segue a figura do programa
desenvolvido neste artigo.

12
 Figura 5 – Protótipo de um Compilador para linguagem de programação robótica

6. PROCEDIMENTOS PARA A ANÁLISE LEXICA

O procedimento para a realização da análise léxica no software para

verificação de sentenças é realizado, como o procedimento acima descreve,
separando as palavras dos caracteres que não são relevantes como, por exemplo,
os espaços em branco. Ou seja, quando é digitado o comando: GIRAR BASE 45 é
selecionado somente as palavras que farão sentido para o funcionamento e
validação do sistema eliminando os espaços em branco, com isso é gerada uma
lista das palavras que fica armazenada no quadro de "Entradas" à direita.

13
Esse trecho descrito acima é realizado pela função atribuída ao botão 1, que segue
abaixo:

1. void __fastcall TForm1::Button1Click(TObject *Sender)

2. {
3. int qtdeLetras;
4. AnsiString entrada = Edit1->Text;
5.
6. qtdeLetras = entrada.Length();
7.
8. int posicaoEspaco = entrada.Pos(" ");
9. palavra1 = entrada.SubString(1, posicaoEspaco - 1);
10.
11. AnsiString aux = entrada.SubString(posicaoEspaco + 1, qtdeLetras);
12. posicaoEspaco = aux.Pos(" ");
13.
14. palavra2 = aux.SubString(1, posicaoEspaco - 1);
15. palavra3 = aux.SubString(posicaoEspaco + 1, qtdeLetras);
16.
17. ListBox1->Items->Add(palavra1);
18. ListBox1->Items->Add(palavra2);
19. ListBox1->Items->Add(palavra3);
20.}

Descrição e detalhamento do código para análise léxica.

Linha 1: Chamada da função ao clicar no botão 1.

Linha 3: instanciação de variável do tipo inteira para armazenar a quantidade
de letras do comando de entrada
Linha 4: instanciação de variável do tipo AnsiString para receber o conteúdo
digitado como comando

14
 Linha 6: a variável criada para armazenar a quantidade de letras recebe o
tamanho total de letras do comando digitado
Linha 8: instanciação de variável do tipo inteira para guardar a posição do
primeiro espaço em branco que for encontrado no comando de entrada digitado
Linha 9: nesse momento ocorre a divisão da primeira palavra a partir do
comando digitado, o método SubString separa a string de entrada, desde seu início
(posição 1) até a posição do espaço em branco -1. Esse conteúdo, que representa a
primeira palavra é armazenada na variável estática "palavra1" criada anteriormente
no escopo geral da aplicação.
Linha 11: instanciação de variável auxiliar do tipo AnsiString para pegar as
informações somente da segunda palavra em diante, ela é gerada a partir da
SubString da posição do primeiro espaço em branco até o final do comando de
entrada, com isso representa a segunda e terceira palavra digitada.
Linha 12: a variável que armazena a posição do espaço em branco é
novamente utilizada, mas agora medirá a posição com base na variável auxiliar
criada anteriormente, ou seja, da segunda palavra em diante ela pegará a posição
do próximo espaço em branco para divisão.
Linha 14: a segunda palavra é dividida tendo como base a variável auxiliar
pegando desde seu início (posição 1) até a ocorrência do espaço em branco - 1
Linha 15: a terceira palavra é dividida utilizando a marcação do espaço em
branco + 1 (que estará posicionado no início da terceira palavra) até o final do
comando digitado.
Linhas 17, 18 e 19: por fim, as palavras divididas são adicionadas uma a uma
na lista (ListBox1) que aparecem à direita.

Feito esse procedimento, as palavras estão prontas para seguir até a próxima
fase, a análise sintática, onde serão comparadas e o sistema retornará um resultado
dizendo se são válidas ou não.

15
 7. PROCEDIMENTOS PARA A ANÁLISE SINTATICA

A análise sintática para o sistema tem a função de verificar se os comandos

digitados, e previamente separados, tem sentido para o robo, ou seja, dado uma
tabela de comandos definidos, referidos como verbos os quais representam ações e
substantivos as partes do robo (que juntos definem o dicionário), é necessário
realizar a comparação do que foi digitado com as ações possíveis de serem
realizadas.

Essa parte do desenvolvimento é representada pelo seguinte trecho de código.

1void __fastcall TForm1::Button2Click(TObject *Sender)

2.{
3. char palavraDicionario[10];
4. Boolean verboOK = false, substantivoOK = false, numeralOK = false;
5.
6. FILE *dicionarioVerbos;
7. dicionarioVerbos = fopen("verbos.txt", "r");
8.
9.
10. if(dicionarioVerbos == NULL )
11. {
12. ShowMessage("Erro ao abrir arquivo!");
13. return;
14. }
15. else
16. {
17. while(!feof(dicionarioVerbos))
18. {
19. fgets(palavraDicionario, 10, dicionarioVerbos);
20.
16
21. if(Boolean igual = SameText(palavraDicionario,palavra1+"\n"))
22. {
23. verboOK = true;
24. }
25. }
26. }
27. fclose(dicionarioVerbos);
28.}

Descrição e detalhamento do código para análise sintática.

Linha 1: Chamada da função ao clicar no botão 2.

Linha 3: instanciação da variável do tipo char para armazenamento das palavras do
dicionário que estarão representadas por arquivos de texto junto com os arquivos da
aplicação.
Linha 4: instanciação das variáveis do tipo booleana para realização de testes
futuros para validar se as palavras do dicionário serão condizentes com o comando
digitado.
Linha 6: instanciação do ponteiro do tipo FILE o qual ficará responsável pelo
direcionamento ao arquivo e sua leitura.
Linha 7: a variável criada para apontar a um arquivo é chamada para realizar
a abertura do arquivo, através da função fopen que contém o nome do arquivo e o
tipo de abertura, que no caso o 'r' representa somente leitura.
Linha 10: nesse momento é realizado um teste para verificar se o arquivo
existe e está no mesmo local que indicado, caso seja nulo, isto é, não seja possível
realizar a sua abertura o sistema enviará uma mensagem na tela do usuário
indicando o estado (representado pelo código das linhas 12 e 13).
Linha 15: caso o arquivo tenha sido aberto com sucesso o comando else dará
continuidade ao andamento do sistema realizando os passos seguintes para a
análise

17
 Linha 17: o comando while fará a leitura do arquivo em questão, nesse caso o
dicionário de verbos (ações do robô representadas pelo primeiro comando de
entrada), até que encontre o seu fim (!feof)
Linha 19: com a leitura até o final do arquivo o comando fgets realiza a
captação dos dados linha a linha armazenando os dados na variável "palavra
Dicionário" criada anteriormente, de seu tamanho "10" para o arquivo relacionado.
Linha 21: instanciação da variável booleana "igual" para verificar o retorno da
função SameText a qual compara duas palavras passadas como parâmetro e
retorna falso ou verdadeiro. Com isso, dependendo do seu retorno, o comando if
atribuirá, caso verdadeiro (palavra digitada igual a palavra da lista de verbos no
dicionário), verdadeiro para a variável (linha 23) "verboOK" indicando que os dois
textos são iguais.
Linha 27: ao final é realizado o fechamento do arquivo

Os mesmos procedimentos são realizados para a validação da segunda

palavra, que representa uma parte do robô, (dicionário de substantivos) e por fim, é
validado o número que o usuário digita utilizando somente número entre 0 e 360 que
representarão o ângulo para movimento.

Após as conferências das palavras digitadas com as palavras do dicionário é

realizada a análise semântica.

8. PROCEDIMENTOS PARA A ANÁLISE SEMÂNTICA

Na análise semântica é necessário validar todos os comandos digitados para

que tenham sentido ao final. Para isso o trecho de código abaixo é realizado para
combinar as palavras (verbos, substantivos e numeral) a fim de produzir um
comando válido.

18
1. if(verboOK && substantivoOK && numeralOK)
2. {
3. if(UpperCase(palavra1) == "GIRAR" && UpperCase(palavra2) == "BASE")
4. {
5. ShowMessage("Sentença válida!");
6. }
7. else if(UpperCase(palavra1) == "ABRIR" && UpperCase(palavra2) ==
"GARRA")
8. {
9. ShowMessage("Sentença válida!");
10. }
11. else if(UpperCase(palavra1) == "FECHAR" && UpperCase(palavra2) ==
"GARRA")
12. {
13. ShowMessage("Sentença válida!");
14. }
15. else if(UpperCase(palavra1) == "ABAIXAR" && UpperCase(palavra2) ==
"ANTEBRACO")
16. {
17. ShowMessage("Sentença válida!");
18. }
19. else if(UpperCase(palavra1) == "LEVANTAR" && UpperCase(palavra2)
== "ANTEBRACO")
20. {
21. ShowMessage("Sentença válida!");
22. }
23. else
24. {
25. ShowMessage("Sentença inválida!\nCorrija as associações:\n\nGIRAR
é uma comando associado somente à BASE\nABRIR e FEHCAR são comandos
associados somente à GARRA\nABAIXAR E LEVANDAR são comandos associados
somente ao ANTEBRACO");
26. }

19
27. }

Na linha 1: é realizada verificação do verbo, substantivo e numeral se foram

válidas anteriormente na análise sintática
Linha 3: começa uma série de análises para verificar as palavras digitadas e
se terão sentido final, isto é, a base somente pode realizar o movimento de rotação.
Caso ela esteja associada ao comando de levantar, abrir, fechar ou abaixar a
sentença não pode ser validado, embora os termos digitados estejam corretos, mas
não será um movimento válido ao robô.
Linha 5: se o comando atribuído for válido, uma mensagem é exibida ao
usuário.

Essas verificações de movimentos com as partes do robô e exibição de

mensagens são realizados nas linhas seguintes até a linha 23. Nessa linha caso
algum comando digitado não seja válido do realizar o movimento, na linha 25 é
informado ao usuário quais movimentos cada parte do robô pode realizar.

20
9. DIAGRAMA USE CASE DO SOFTWARE

Figura 6 – Diagrama Use Case da linguagem de programação robótica

21
10. DIAGRAMA DFA DO SOFTWARE

1 Letra 2 Letra 3 Dígito 4

Figura 7 – Diagrama DFA da linguagem de programação robótica

11. CONCLUSÃO

O objetivo desse artigo foi elaborar uma linguagem para programação de

robôs manipuladores onde fosse facilitada a forma de programar hardwares
mecânicos. Esses hardwares são desenvolvidos pelos alunos do curso de
Engenharia de Controle e Automação da FAJ.

A ferramenta criada está baseada no robô manipulador que consta na figura 2

desse artigo.

O software não foi testado com o robô, embora esteja funcionando

corretamente de acordo com o planejamento elaborado.

Chegamos à conclusão que para programar de forma eficiente um robô, não

são necessários muitos comandos. Com a estrutura elaborada no software
desenvolvido neste artigo, é possível programar um protótipo mecânico, sem que
haja um conhecimento aprofundado em regras de criação de códigos, contanto é
esperado que o programador atente-se quanto à atribuição dos comandos a
serem passados para o hardware mecânico, ou seja, para que ele possa atender
a solicitação do programador é necessário que ele siga as regras que foram
definidas no software.

22
12. REFERÊNCIAS BIBLIOGRÁFICAS

ALFRED V. AHO & JEFFREY D. ULLMAN & REVI SETHI. Compiladores:

Princípios, Técnicas e Ferramentas . Rio de Janeiro: LTC, 1995. 344p.

CRAIG, John J. Introduction to Robotics: Mechanics and Control. 2. ed. 1989.

459p.

LOUDEN, Kenneth C. Compiladores: princípios e práticas. São Paulo:

Thomson, 2004. 569p

MANSSOUR, Isabel Harb. Linguagem de Programação C. Disponível em:

http://www.inf.pucrs.br/~manssour/LinguagemC/. Acesso em: 26 mai. 2009.

SCHILDT, Herbert. C Completo e Total. 3. ed. São Paulo: Makron Books,

1996. 827p.

Mecatrônica Atual, Linguagem de Programação de Robôs

http://www.mecatronicaatual.com.br/secoes/leitura/418. Acesso em 10 jan.
2009.

23
ANEXO – CÓDIGO FONTE DO SOFTWARE ELABORADO NO ARTIGO

#include <vcl.h>
#include<stdlib>
#include<string>
#include<cstdio>
using namespace std;
#pragma hdrstop

#include "TCC.h"
#include "Ajuda.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;

static AnsiString palavra1;

static AnsiString palavra2;
static AnsiString palavra3;

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{

}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
int qtdeLetras;
AnsiString entrada = Edit1->Text;

24
 qtdeLetras = entrada.Length();

int posicaoEspaco = entrada.Pos(" ");

palavra1 = entrada.SubString(1, posicaoEspaco - 1);

AnsiString aux = entrada.SubString(posicaoEspaco + 1, qtdeLetras);

posicaoEspaco = aux.Pos(" ");

palavra2 = aux.SubString(1, posicaoEspaco - 1);

palavra3 = aux.SubString(posicaoEspaco + 1, qtdeLetras);

ListBox1->Items->Add(palavra1);
ListBox1->Items->Add(palavra2);
ListBox1->Items->Add(palavra3);
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)

{
char palavraDicionario[10];
Boolean verboOK = false, substantivoOK = false, numeralOK = false;
//LEITURA DOS VERBOS E COMPARAÇÃO

FILE *dicionarioVerbos;
dicionarioVerbos = fopen("verbos.txt", "r");

if(dicionarioVerbos == NULL )
{
ShowMessage("Erro ao abrir arquivo!");

25
 return;
}
else
{
while(!feof(dicionarioVerbos))
{
fgets(palavraDicionario, 10, dicionarioVerbos);

if(Boolean igual = SameText(palavraDicionario,palavra1+"\n"))

{
verboOK = true;
}
}
}
fclose(dicionarioVerbos);

//FINAL LEITURA DOS VERBOS E COMPARAÇÃO

//LEITURA DOS SUBSTANTIVOS E COMPARAÇÃO

FILE *dicionarioSubstantivos;
dicionarioSubstantivos = fopen("substantivos.txt", "r");
char palavraSubstantivos[15];

if(dicionarioSubstantivos == NULL )
{
ShowMessage("Erro ao abrir arquivo!");
return;
}
else
{
while(!feof(dicionarioSubstantivos))
{
fgets(palavraDicionario, 15, dicionarioSubstantivos);

26
 Boolean igual = SameText(palavraDicionario,palavra2+"\n");
if(igual == true)
{
substantivoOK = true;
}
}
}
fclose(dicionarioSubstantivos);
//FINAL LEITURA DOS SUBSTANTIVOS E COMPARAÇÃO

//LEITURA DOS NUMEROS E COMPARAÇÃO

int numeral;
numeral = StrToInt(palavra3);

if(numeral >= 0 && numeral <= 360)

{
numeralOK = true;
}
//FINAL LEITURA DOS VERBOS E COMPARAÇÃO

if(verboOK && substantivoOK && numeralOK)

{
if(UpperCase(palavra1) == "GIRAR" && UpperCase(palavra2) == "BASE")
{
ShowMessage("Sentença válida!");
}
else if(UpperCase(palavra1) == "ABRIR" && UpperCase(palavra2) ==
"GARRA")
{
ShowMessage("Sentença válida!");
}
else if(UpperCase(palavra1) == "FECHAR" && UpperCase(palavra2) ==
"GARRA")

27
 {
ShowMessage("Sentença válida!");
}
else if(UpperCase(palavra1) == "ABAIXAR" && UpperCase(palavra2) ==
"ANTEBRACO")
{
ShowMessage("Sentença válida!");
}
else if(UpperCase(palavra1) == "LEVANTAR" && UpperCase(palavra2) ==
"ANTEBRACO")
{
ShowMessage("Sentença válida!");
}
else if(UpperCase(palavra1) == "ABAIXAR" && UpperCase(palavra2) ==
"PUNHO")
{
ShowMessage("Sentença válida!");
}
else if(UpperCase(palavra1) == "LEVANTAR" && UpperCase(palavra2) ==
"PUNHO")
{
ShowMessage("Sentença válida!");
}
else
{
ShowMessage("Sentença inválida!\nCorrija as associações:\n\nGIRAR é
uma comando associado somente à BASE\nABRIR e FECHAR são comandos
associados somente à GARRA\nABAIXAR E LEVANTAR são comandos associados
somente ao ANTEBRACO E AO PUNHO");

}
}
else

28
 {
if(verboOK == false)
ShowMessage("Sentença inválida! Corrija o primeiro termo!");
if(substantivoOK == false)
ShowMessage("Sentença inválida! Corrija o segundo termo!");
if(numeralOK == false)
ShowMessage("Sentença inválida! Corrija o terceiro termo!");
}
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button3Click(TObject *Sender)

{
ListBox1->Items->Clear();

Edit1->Text = "";
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button4Click(TObject *Sender)

{
Form1->Close();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Comoutilizar1Click(TObject *Sender)

{
Form2->ShowModal();

29