linguagem de programação para robôs manipuladores

1

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.

2

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.

3

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

4

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.

5

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.

6

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

7

Figura 2 – Esquema de um robô manipulador

Base

Braço

Articulação

Punho

Articulação

Articulação

Garra

8

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

9

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

10

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

11

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

12

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.

13

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.

14

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



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

15

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.

16

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.

17

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

18

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.

19

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


10. }

11. else if(UpperCase(palavra1) == "FECHAR" && UpperCase(palavra2) ==

"GARRA")

12. {


14. }

15. else if(UpperCase(palavra1) == "ABAIXAR" && UpperCase(palavra2) ==

"ANTEBRACO")

16. {


18. }

19. else if(UpperCase(palavra1) == "LEVANTAR" && UpperCase(palavra2)

== "ANTEBRACO")

20. {


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

20

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.

21

9. DIAGRAMA USE CASE DO SOFTWARE

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

22

10. DIAGRAMA DFA DO SOFTWARE

Letra Letra Dígito

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.

1 2 3 4

23

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.

http://www.inf.pucrs.br/~manssour/LinguagemC/

http://www.mecatronicaatual.com.br/secoes/leitura/418

24

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;



//---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

{

int qtdeLetras;

AnsiString entrada = Edit1->Text;

25

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



}

//---------------------------------------------------------------------------


{

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

26

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

27

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

{


}

else if(UpperCase(palavra1) == "FECHAR" && UpperCase(palavra2) ==

"GARRA")

28

{


}

else if(UpperCase(palavra1) == "ABAIXAR" && UpperCase(palavra2) ==

"ANTEBRACO")

{


}

else if(UpperCase(palavra1) == "LEVANTAR" && UpperCase(palavra2) ==

"ANTEBRACO")

{


}

else if(UpperCase(palavra1) == "ABAIXAR" && UpperCase(palavra2) ==

"PUNHO")

{


}

else if(UpperCase(palavra1) == "LEVANTAR" && UpperCase(palavra2) ==

"PUNHO")

{


}

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

29

{

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

}

}

//---------------------------------------------------------------------------


{

ListBox1->Items->Clear();

Edit1->Text = "";

}

//---------------------------------------------------------------------------


{

Form1->Close();

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Comoutilizar1Click(TObject *Sender)

{

Form2->ShowModal();

linguagem de programação para robôs manipuladores

Documents