MODELAGEM DAS REGRAS

Das três variáveis envolvidas no sistema, apenas duas foram trabalhadas na lógica Fuzzy (a distância do sensor e o ângulo da direção), para a velocidade do veículo foi adotado um valor padrão fixo e o seu controle foi feito com base na lógica convencional.

Para as outras duas variáveis foram formulados os seguintes conjuntos para representá-las: a variável lingüística “DistânciaDoSensor” foi associada ao conjunto representado graficamente na Figura 39, e a variável “ÂnguloDaDireção” com o conjunto da Figura 40.

A “DistânciaDoSensor” foi dividida em cinco termos:

 O “muitoPerto”, que representa a eminência de colisão e vai de 0 a 6 cm, sendo que para valores menores que 4 cm ele tem altura máxima, isso porque nessa faixa de valores o sensor não garante aferição das medidas;

 “Perto” que vai de 4 a 10 cm;

 “Médio”, que vai de 9 a 16 cm;

 “Longe” que vai de 15 a 23 cm; e

 O “muitoLonge” que vai 20 cm a infinito. Este tem sua altura máximo a partir de 25 cm, porque a partir de 30 cm em o sensor não garante mais a aferição das medidas.

Figura 39: Função Fuzzy que representa a variável lingüística "DistânciaDoSensor".

O “ÂnguloDaDireção” foi dividido em cinco termos também: “muitoDireita”, “direita”, “alinhado”, “esquerda”, “muitoEsquerda”. Apesar do carro só ter três ângulos de direção discretos, a direção é calculada com base na lógica Fuzzy. Para funcionar com o sistema o protocolo trata de verificar entre quais faixas está o valor inferido para a direção, e com base nisso adota uma das três direções possíveis.

Figura 40: Função Fuzzy que representa a variável lingüística "ÂnguloDaDireção".

Para o sistema iniciar o processo de estacionamento, inicialmente o carro deverá estar na posição inicial pré-estabelecida, conforme mostra a Figura 41 (a).

Quando o processo de estacionamento é iniciado o carro é posto em marcha ré e são chamadas as regras que modelam o movimento do carro quando anda para trás.

As regras mostradas na Figura 42 foram modeladas para fazer o carro começar a entrar na vaga no momento em que ele chega à posição mostrada no gráfico da Figura 41 (b) e continue até a posição da Figura 41 (d). Esse trajeto é percorrido com a direção virada para a direita e andando para trás.

Cada sigla mostrada nas regras representam uma especificação do termo “distânciaDoSensor”: ST (sensor traseiro), STDD (sensor traseiro diagonal direito), STLD (sensor traseiro lateral direito), SFLD (sensor frontal lateral direito), SFDD (sensor frontal diagonal direito) e SFDD (sensor frontal diagonal direito).

Para a próxima parte do trajeto que vai da Figura 43 (a) até (b), foram criadas as regras mostradas na Figura 44 para fazer o carro virar a direção para a esquerda e começar a se posicionar dentro da vaga.

Figura 43: Carro entrando na vaga com direção para esquerda - andando para trás.

//Entrar na vaga

Se(STDD(muitoLonge) && SFLD(perto)) //para trás && ângulo muitoDireita; Se(STDD(longe) && SFLD(perto))

//para trás && ângulo muitoDireita; Se(ST(longe) && STDD(longe) && SFLD(medio))

//para trás && ângulo muitoDireita;

Se(ST(muitoLonge) && STDD(longe) && SFLD(medio)) //para trás && ângulo muitoDireita;

if(ST(muitoLonge) && STDD(muitoLonge) && SFLD(medio)) //para trás && ângulo para muitoDireita

A partir deste ponto o carro já está na vaga e é iniciado o processo de alinhamento. Como o sensor traseiro está muito perto o carro muda de direção. As regras que modelam a mudança de direção não são regras Fuzzy, usam a lógica convencional. As condições nas quais o carro muda de direção quando está indo para trás estão mostradas na Figura 45.

Quando o carro muda de direção, passam a ser acionadas as regras que modelam o movimento do carro para frente no processo de alinhamento. As regras mostradas na Figura 46 controlam o trajeto em que o carro vai para frente, onde a direção está virada para a direita. Esse trajeto é mostrado na Figura 47 (a) e (b).

//Entrar na vaga

Se(ST(medio) && SFLD(muitoLonge))

//para trás && ângulo para muitoEsquerda; Se(STDD(medio) && SFLD(muitoLonge))

//para trás && ângulo para esquerda; Se(ST(medio) && SFLD(longe))

//para trás && ângulo para esquerda; Se (STDD(medio) && SFLD(longe))

//para trás && ângulo para esquerda;

Se(ST(muitoLonge) && STDD(muitoLonge) && SFLD(medio)) //para trás && ângulo para muitoDireita;

Figura 44: Regras que modelam a entrada no carro na vaga – para trás e para esquerda.

//Regra não Fuzzy - muda só a direção do veículo Se(ST(muitoPerto))

paraFrente();

Se(STDD(muitoPerto) && !STLD(muitoPerto)) paraFrente();

Se(ST(muitoPerto) && STLD(muitoPerto)) paraFrente();

Figura 47: Para frente e para direita - alinhando.

//Alinhando na vaga Se(SFLD(muitoLonge))

//para frente && ângulo muitoDireita; Se(SFLD(longe))

//para frente && ângulo muitoDireita; Se(SFLD(medio))

//para frente && ângulo para direita;

Ainda andando para frente e alinhando, nas situações em que o carro está perto do carro da frente ou do meio fio, ele muda a direção para a esquerda. Esse caso é modelado pelas regras da Figura 48, e o trajeto é mostrado na Figura 49.

Figura 49: Para frente e para esquerda - alinhando.

//Para esquerda

Se(STLD(medio) && SFLD(perto) && SF(perto)) //para frente && ângulo muitoEsquerda; Se(STLD(medio) && SFLD(medio) && SF(perto))

//para frente && ângulo muitoEsquerda;

Quando o carro está indo para frente e na eminência de choque alguma das regras não Fuzzy mostradas na Figura 50 é acionada fazendo o carro muda de direção.

Quando o carro começa a andar para trás e o sensor traseiro diagonal direito ainda não é perto, o carro seguirá as regras que são mostradas na Figura 51, cumprindo o trajeto da Figura 52. A partir do momento em que ele é perto, o sistema tem alguma das funções da Figura 53 ativadas e vira a direção para a esquerda fazendo o percurso da Figura 54.

//Regra não Fuzzy Se(SF(muitoPerto))

paraTras();

Se(SFDD(muitoPerto) && !SFLD(muitoPerto)) paraTras();

Se ((SFLD(muitoPerto) || SFDD(muitoPerto)) && !(SFLD(muitoPerto) || SFLD(perto)) ) paraTras();

Figura 50: Regras não Fuzzy que decidem quando o carro vai mudar de trajetória.

//Para Alinhar

Se(STDD(muitoLonge) && SFLD(muitoPerto)) //para trás && ângulo muitoDireita Se(STDD(longe) && SFLD(muitoPerto))

//para trás && ângulo muitoDireita Se(SFLD(medio) && ST(longe))

//para trás && ângulo muitoDireita Se(SFLD(medio) && ST(muitoLonge)){

//para trás && ângulo muitoDireita

Se(STDD(medio) && STLD(perto) && SFLD(perto) && SF(muitoPerto)){ //para trás && ângulo muitoDireita

Se(STDD(medio) && STLD(perto) && SFLD(perto) && SF(perto)){ //para trás && ângulo muitoDireita

Figura 54: Para trás e para esquerda - alinhando.

//Alinhar

Se(ST(perto) && SFLD(muitoLonge)) //para trás && ângulo muitoEsquerda Se(STDD(perto) && SFLD(muitoLonge))

//para trás && ângulo muitoEsquerda Se(ST(perto) && SFLD(longe))

//para trás && ângulo muitoEsquerda Se(STDD(perto) && SFLD(longe))

//para trás && ângulo muitoEsquerda Se(STLD(muitoPerto) && SFLD(perto)){

//para trás && ângulo para esquerda Se(STDD(perto) && SFDD(medio))

//para trás && ângulo muitoEsquerda

O percurso descrito pelas Figuras 55 e 56 usa as mesmas regras para alinhar o carro indo para frente, mostradas nas Figuras 46 e 48.

Para este exemplo específico, algumas regras não foram usadas, contudo, como o ponto de partida do carro pode variar, elas se fazem necessárias.

Essas regras foram modeladas inicialmente tomando-se por base alguns esboços gráficos. No segundo passo elas foram aperfeiçoadas para funcionar com o auxílio do “Mundo Virtual”, que simula o sistema no carro. E por último, já controlando o sistema no carro, foram adicionadas novas regras para cobrir os casos não previstos inicialmente.

Figura 56: Para frente e para esquerda - alinhado.

O controlador trabalha com os valores dispostos na classe “ModeloDeMundo” mostrada no diagrama da Figura 35. A responsabilidade de manter o modelo de mundo sincronizado com o sistema real, ou a sua simulação, fica à cargo da classe “Protocolo”, também mostrado no mesmo diagrama.