Tutorial em Português - Como

direcionar os itens usando o recurso

List1
Paula Carneiro Martins criado ∙ 16 de Feb às 12:36
1
É comum precisarmos de múltiplas etapas para finalizarmos a
produção de um produto. Na produção de uma calça, por exemplo, de
uma forma simplificada, precisamos cortar o tecido de acordo com o
molde, costurar , colocar os botões e o zíper , e por último, empacotar.
E assim cada produto tem a sua ordem de processos que são
necessários para a sua finalização. Nesse exemplo vamos construir
um modelo que usa list para rotear itens de acordo com as etapas
necessárias para a sua finalização em um modelo simples de chão de
fábrica.

Passo 1. Construir layout

Para fazermos o exemplo precisaremos de um layout com 8
processors, 1 source e uma queue. Adicione esses objetos no seu
modelo e os renomeie conforme Figura 1.

Figura 1- Layout exemplo 1

Como a Figura 1 mostra, existem basicamente 4 tipos de operações:

 Alpha – 2 estações;
  Beta – 2 estações;

 Gamma – 2 estações;

 Delta – 2 estações.

Passo 2. Adicionar lists

Para adicionar a lógica é preciso criar item list. Em Toolbox> > Global
list> Item list(Figura 2).

Figura 2- Adicionar Item List

Ao clicar em Item list irá abrir janela de propriedades da lista (Figura

3), por agora apenas fechar a aba. A sua lista está nomeada como
ItemList1.
Figura 3- Janela de propriedades Itemlist

Passo 3. Adicionar Global table

Nesse modelo nós vamos ter 3 diferentes tipos de produtos
classificados por tipo de item (item type). Cada tipo de produto tem
uma sequência única para ser executada nesse item até que esse
esteja pronto. A Tabela 1 mostra a sequência de passos de
manufatura que cada tipo de produto requesita.

Tabela 1- Sequência de passos por produto

Em Toolbox> >Global table. Em Global table modificar o número de

linhas(rows) para 8 e de colunas(columns) para 3. Renomeie as linhas
e as colunas conforme Figura 4.
Figura 4- Global Table

Para colocarmos a sequência, é necessário configurar a tabela para

uma tabela que aceita palavras. Selecione todas as células > Clique
no botão direito> Assign String Data (Figura 5). Agora podemos digitar
palavras.
Figura 5- Permitir palavras como dados

Renomear a global table para Steps, e acrescentar a sequência

necessária para cada tipo (Figura 6).

Figura 6- Global table preenchida

Passo 4. Configurar Source

Para voltarmos para o modelo clique sobre a aba Model no canto

superior esquerdo

Dê duplo clique sobre o source. Configure o inter-arrival time em

exponencial (0,30,0), como pode-se observar na Figura 7.
Figura 7- Configuração source

Agora na aba Flow, em Send to port (barra de rolagem)> Use list> Push
to item list (Figura 8).
Figura 8- Selecionar método puxado de uma lista

Ao clicar em Push to Item List, uma janela irá abrir com o nome da list
selecionada. Verifique se o nome da lista é IGUAL ao da lista que você
criou (Figura 9).

Figura 9- Verificar nome da lista

Em Triggers, On Creation adicione as triggers Set Label com a label

relacionada ao objeto ITEM e chamada “stepRow” e valor igual a 1, e
Set the Itemtype and Color como duniforme (1, 3).
Figura 10- Triggers source

Passo 5. Definir list

Em Toolbox, dê duplo clique sobre o ItemList1, quando abrir a janela

de propriedades observe que há algumas expression field já
adicionadas. Mas nesse modelo nós devemos usar apenas 3 fields.

 stepRow: Esse campo irá referenciar a atual setRow label no

item. Nós vamos utiliza-la para priorizar itens que estão
avançados nos seus processos;

 step: Esse campo vai referenciar o nome do atual passo que o

item está. Por exemplo, Alpha,Beta,Gamma, ou delta. Nós vamos
usar isso para direcionar para a próxima etapa que vai puxar da
lista;

 itemType- Esse campo não será utilizado em nenhuma consulta.

Apesar disso, ele irá ser usado para facilitar a visualização dos
itens que estão na lista.

Dessa forma, exclua todas as fields EXCETO a ItemType. Dessa forma,

deve-se criar mais duas fields.
 1.Adicionar uma label field chamada stepRow.

2.Adicionar uma Expression field colocar a seguinte expressão

Getttablestr(“steps”,getlabel(value”steprow”),getitemtype(value))

Na expressão você vai usar "value" para acessar o valor primário da

lista. Essa expressão pega um valor da tabela dos passos
(gettablestr("steps", ... ) , onde a linhá é o atual valor do steprow
(getlabel(value, "steprow")), e a coluna é o tipo de item
(getitemtype(value)).

No final desses passos a janela de propriedades da lista deve se

parecer com a Figura 11.

Figura 11- Propriedades preenchidas do itemlist

DETALHE: Lembre-se que se vc nomeou a tabela, ou a label de forma

diferente é preciso que nesse momento elas sejam citadas como
foram nomeadas.

** Teste rápido**

Para verificar se até aqui as coisas estão funcionando da maneira

correta. Vamos fazer um test rápido. Nas propriedades do ItemList1,
vá na aba General e clique no botão a esquerda “ View entries”.
Coloque o modelo para rodar, após a primeira chegada o tempo vai
expirar e a tela do list deve se parecer com a Figura 12.
Figura 12- Visualização das entradas na list

Passo 6. Configurar processos

Passo 6.1. Adicionar label aos processos

Clique sobre Alpha 1 e na aba Labels> > Add String Label (Figura 13).

Figura 13- Adcionar uma

label ao processo

Em newstringlabel nomear
como operation e o valor
colocar como Alpha
conforme mostra a Figura
14.

Figura 14- Label operation

Passo 6.2. Criar lógica de fluxo de saída

Ainda nas propriedades do Alpha 1, na aba Flow , na opção Sento to
port, pressione a lista de opções escolha Use List> Push to item list
(Figura 15). Ao clicar em Push to Item list aparecerá uma janela com o
nome da lista, confira se o nome da lista coincide com a lista que
criamos (ItemList1).
Figura 15- Puxar da lista

Passo 6.3. Criar lógica de fluxo de entrada

Ainda na aba Flow, na subárea Input, escolha a opção pull e depois em
Pull Strategy abra a lista de opções , em Use list escolha Pull from the
Item List (Figura 16).
Figura 16- Criar estratégia de entrada

Verifica se o nome da lista e o nome da lista que você adicionou

conferem. E defina Query como:
WHERE step == Puller.operation ORDER BY steprow DESC

Essa expressão vai fazer com que o processo puxe somente os itens
da lista cujo o step field corresponde a label do processo. Ela também
cria uma regra de priorização de itens com o maior stepRow label, ou
seja, itens que estão em passos mais adiantados dos seus processos
(Figura 17).

Figura 17- Query

OBS : Se atende aos detalhes da fórmula do QUERY, não esqueça do

ponto. E não se preocupe do operation e do steprow não aparecerem
como opção de lista. É normal! Apenas se certifique que a está
escrito exatamente como escrito na fórmula acima.
Passo 6.4. Criar lógica de atualização da label
Na aba Triggers, vá em OnProcessFinish > Adicionar > Data > Set
Label (Figura 18).

Figura 18- Adicionar nova label no final do processo

Como precisamos atualizar a label para que ela siga a entidade até
que essa finalize todos os seus passos até o fim do seu processo. É
preciso configurar a label para o OBJETO item, a label stepRow com
um valor de getlabel(item,”stepRow”)+1. A Figura 19 mostra como
deve ficar a tela da label.

Figura 19- Atualização da label

Passo 6.5. Replicar propriedades para os outros

processos.
Para os outros processos nós devemos repetir 6.1 ao 6.4,sendo que no
6.1 é necessário mudar o nome da label operation de acordo com a
Tabela 2.

Tabela 2- Como renomear as labels por processo

Ou nós podemos copiar todas as propriedades do Alpha 1 para todos

os outros processos e depois adicionar as labels operation de acorda
com cada categoria.

Passo 7. Configurar finish queue

Passo 7.1. Adicionar label no processo

Clique na finish queue , vá na aba labels adicione uma String label,
com o nome de operation e com o value de Finish (Figura 20).

Figura 20- Label finish

Passo 7.2. Criar lógica do fluxo

Na aba flow , na subárea Input, escolha a opção pull e depois em Pull
Strategy abra a lista de opções , em Use list escolha Pull from the
Item List. Defina o pull query como

Where step == puller.operation. Nesse caso não há necessidade de

priorizar, já que a fila é nesse caso o fim da operação.

Salve seu modelo e coloque para simular!

exemplo1-pullsystem.fsm

Rack

https://www.youtube.com/watch?v=mIBkcgWVQew

1º Modelo

Sendo:

Centur 50 B 1 = montado para caixa

Multiplic 60 = montado para caixa

Centur 50 = Pino

Centur 50 = Pino

Tutorial em Português - AStar Navigator

- Exemplo Passo a Passo

Tutorial em Português - AStar

Navigator - Exemplo Passo a Passo
Rodrigo Lamas criado ∙ 26 de Jan às 08:31 ∙ Paul T editada ∙ 27 de Feb às
10:03

1
Neste Tutorial iremos demonstrar em um exemplo como funciona a
biblioteca AStar Navigator no FlexSim.
O AStar Navigator, também conhecido como A*, é um algoritmo de
busca usado para encontrar um caminho entre pontos, e serve para
determinarmos o trajeto pelo qual os executores de tarefas podem se
movimentar pelo modelo. Esta biblioteca permite que você crie e
defina barreiras físicas para a correta movimentação dos executores
de tarefas em seu modelo.

Nós iremos usar o seguinte modelo para mostrar como o A*

Navigator pode ser usado em um modelo simples. astar-example-
model.fsm
Crie o A* Navigator
Primeiro, um objeto AStarNavigator deve ser adicionado ao modelo.
Somente um objeto AStarNavigator faz-se necessário e permitido por
modelo.

Crie um objeto AStarNavigator ao clicar e arrastar da biblioteca para

qualquer posição na superfície de simulação em 3D.

Conectando os Membros
Neste modelo, existe apenas um objeto executador de tarefa
(TaskExecuter), no entanto, nós também queremos incluir o Rack
como uma barreira.

Faça um conexão com o 'A' entre o AStarNavigator e o operador. Isto

pode ser feito mantendo a tecla A pressionada e clicando/arrastando
do AStarNavigator para o operador, ou do operador para o
AStarNavigator (não importando a ordem ou sequência de onde tem
que partir a conexão). Um círculo em azul irá aparecer abaixo do
operador.

Faça uma conexão com o 'A' entre o AStarNavigator e o Rack. Um

retângulo em azul irá aparecer abaixo do Rack. Adicione um Source e
um Queue próximo ao operador conforme você pode visualizar em
outra imagem mais abaixo.

Criando Barreiras (Barriers)

Junto com o Rack, vamos também criar um par de barreiras para
representar paredes ou obstáculos que o operador não pode caminhar
através.

Clique no ícone do Divider na biblioteca para entrar no modo de

criação.

Clique em algum lugar ao lado direito do Queue (buffer) para criar um

novo Divider.

Clique duas vezes mais próximo dos pontos para mostrar a imagem
abaixo para finalizar o Divider.

Clique com o botão direito do mouse para sair do modo de criação.

Adicione os Processors e um Sink conforme imagens abaixo. Faça a
conexão deste o Source até o Sink usando a conexão com “A”.

Clique sobre o ícone Barrier na biblioteca para entrar no modo de

criação.

Clique uma vez onde o canto esquerdo inferior do Barrier estará como
mostrado abaixo.

Clique novamente no canto direito superior para completar a

configuração do Barrier.

Clique com o botão direito para sair do modo de criação.

Coloque o Barrier abaixo do Rack.

Execute o Modelo
Você pode agora resetar e executar o modelo para ver como será a
performance do operador. Lembre-se, se você fizer qualquer mudança
nas suas barreiras, o modelo obrigatoriamente deve ser resetado
antes de ser executado novamente.

Note que o operador encontrou o menor caminho para movimentar-se

por cima e por fora do Divider. Embora exista diversas formas de
alterar os caminhos do operador (por exemplo, estender ainda mais o
tamanho do Divider), nós iremos modificar o caminho percorrido pelo
operador, usando o Preferred Path.

Crie Preferred Paths

Preferred paths não são caminhos “configuráveis”, em vez disso, dará
aos nodes associados com o caminho preferido, um peso maior no
algoritmo de busca. Isso vai nos afetar, e puxar o operador para o
caminho preferido.

Clique sobre o ícone Preferred Path na biblioteca para entrar no modo

de criação.

Crie os dois seguintes Preferred Paths conforme mostrado na imagem

abaixo. Preferred paths são unidirecionais e além do mais precisa ser
posicionado no layout na ordem correta.

Clique com o botão direito do mouse para sair do modo de criação.

Execute o Modelo
Resete e execute o modelo.
Se o seu operador continuar a movimentar para cima e fora do Divider,
você pode ou movimentar o Preferred Path ou alterar o Preferred Path
weight na janela de propriedades do objeto AStarNavigator.
Os Resultados do seu modelo podem variar deste exemplo conforme
você posiciona suas barreiras e objetos, o que pode fazer a diferença
no cálculo dos caminhos do operador.

AStar Navigator Library

O AStar é acessado na Biblioteca principal a esquerda: View Menu /
Drag-Drop Library

Existem 5 tipos de barreiras usada pelo A* Navigator. Estas barreiras

modificam a grade usada no algoritmo de busca.

Nota: Uma vez que as barreiras são criadas ou modificadas, o modelo

precisa ser Resetado para recalcular o node table.
Solid Barrier
A mais simples das barreiras, a barreira sólida modifica a grade para
remover uma área retangular, prevenindo os membros de viajar e
(travel members) se movimentarem dentro da barreira.

Divider

Dividers desconectam os nodes ao longo de seu caminho, prevenindo

os travel members de atravessarem o divider. Dividers podem ser
modificados na superfície de simulação 3D ao arrastar o ponto final e
intermediário. Qualquer número de pontos pode ser adicionado ao
divider.

One-Way Divider

O One-way divider funciona de forma muito similar ao divider, no

entanto, travel members são permitidos se movimentarem através do
divider na direção das flechas em verde, neste caso, em direção ao
topo da página. O one-way dividers pode ser modificado na superfície
de simulação em 3D ao arrastar os pontos finais ou intermediários.
Qualquer número de pontos podem ser adicionados em um one-way
divider.

Preferred Path
Embora o preferred path não é uma barreira real, ele funciona da
mesma forma que as barreiras fazem para modificar a tabela de nodes
do A* Navigator. Em vez de modificar os nodes removendo os seus
indicadores de direção, o caminho preferencial dá um peso maior a
todos os nós associados com o percurso. Este valor de Path Weight
pode ser alterado através da janela de propriedades do A * Navigator.
O Path Weight tem de ser maior do que 0 e menor que 1, a fim de
funcionar adequadamente. Valores acima ou abaixo deste podem
causar resultados não intencionais. Os preferred paths podem ser
modificados na visualização em 3D, arrastando os pontos do fim ou do
meio. Preferred paths são unidirecionais. Qualquer número de pontos
pode ser adicionado a um preferred path.

{ // ************* PickOption Start ************* //

/***popup:ItemTypePercentage:valuestr=Type*/

/**Set Item Type by Percentage*/

int stream = /**\nStream number: *//***tag:stream*//**/0/**/;

double randomnum = uniform(0.0, 100.0, stream);

double total = 0.0;

int foundmatch = 0;

/***tagex:data*/

total += /**\nPercent: *//**/10/**/;

if (!foundmatch && randomnum <= total) {

item.Type = /** Type: *//**/current.PPM/**/;

foundmatch = 1;

total += /**\nPercent: *//**/10/**/;

if (!foundmatch && randomnum <= total) {

item.Type = /** Type: *//**/current.PSM/**/;

foundmatch = 1;

}
total += /**\nPercent: *//**/10/**/;

if (!foundmatch && randomnum <= total) {

item.Type = /** Type: *//**/current.PCM/**/;

foundmatch = 1;

total += /**\nPercent: *//**/10/**/;

if (!foundmatch && randomnum <= total) {

item.Type = /** Type: *//**/current.CCM/**/;

foundmatch = 1;

total += /**\nPercent: *//**/10/**/;

if (!foundmatch && randomnum <= total) {

item.Type = /** Type: *//**/current.CSM/**/;

foundmatch = 1;

total += /**\nPercent: *//**/10/**/;

if (!foundmatch && randomnum <= total) {

item.Type = /** Type: *//**/current.PPN/**/;

foundmatch = 1;

total += /**\nPercent: *//**/10/**/;

if (!foundmatch && randomnum <= total) {

item.Type = /** Type: *//**/current.PSN/**/;

foundmatch = 1;

total += /**\nPercent: *//**/10/**/;

if (!foundmatch && randomnum <= total) {

item.Type = /** Type: *//**/current.CCN/**/;

foundmatch = 1;

total += /**\nPercent: *//**/10/**/;

if (!foundmatch && randomnum <= total) {

item.Type = /** Type: *//**/current.CSM/**/;

foundmatch = 1;

}/***/

} // ******* PickOption End ******* //