Vous êtes sur la page 1sur 29

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. 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.

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.

de programação para robôs existentes no mercado. Figura 1 – Extraída da Revista Mecatrônica Atual de

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

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.

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.

ao

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

FECHAR:

Comando associado

servo-motor GARRA.

Esse comando

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

Braço

Braço Articulação Base Articulação Punho Garra Articulação Figura 2 – Esquema de um robô manipulador 7
Articulação Base
Articulação
Base

Articulação

Punho

Garra

Articulação

Figura 2 Esquema de um robô manipulador

4. COMO

A

LINGUAGEM

DE

PROGRAMAÇÃO

MANIPULADORES PODERÁ SER USADA

DE

ROBÔS

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

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

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.

de origem e está pronto para receber novas instruções de seu programador. Figura 3 - Robô

Figura 3 - Robô em seu estado inicial

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ô.

foi feita manualmente e o comando associado refere-se a base do robô. Figura 4 – Robô

Figura 4 Robô após receber comando

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.

Figura 5 – Protótipo de um Compilador para linguagem de programação robótica 6. PROCEDIMENTOS PARA

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.

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

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.

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.

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

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.

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. }

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.

9.

DIAGRAMA USE CASE DO SOFTWARE

9. DIAGRAMA USE CASE DO SOFTWARE Figura 6 – Diagrama Use Case da linguagem de programação

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

10.DIAGRAMA DFA DO SOFTWARE Letra Letra 1 2
10.DIAGRAMA DFA DO SOFTWARE
Letra
Letra
1
2
3 Dígito 4
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.

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:

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.

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;

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!");

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);

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")

{

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

{

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();